wordlist_codegen.rs

// This file is @generated by tests/testsuite/codegen.rs

pub(crate) static ACCEPT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("accept", ())],
    },
};

pub(crate) static ACCESS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("access", ())],
    },
};

pub(crate) static ADD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("add", ())],
    },
};

pub(crate) static ADJUST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("adjust", ())],
    },
};

pub(crate) static AGGREG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("aggregate", ())],
    },
};

pub(crate) static ALLOW_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("allow", ())],
    },
};

pub(crate) static APPEND_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("append", ())],
    },
};

pub(crate) static APPLI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("apply", ())],
    },
};

pub(crate) static ARCHIV_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("archive", ())],
    },
};

pub(crate) static ASSERT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("assert", ())],
    },
};

pub(crate) static ASSIGN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("assign", ())],
    },
};

pub(crate) static ATTEMPT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("attempt", ())],
    },
};

pub(crate) static AUTHENT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("authenticate", ())],
    },
};

pub(crate) static AUTHOR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("authorize", ())],
    },
};

pub(crate) static BREAK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("break", ())],
    },
};

pub(crate) static BUILD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("build", ())],
    },
};

pub(crate) static CACH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("cache", ())],
    },
};

pub(crate) static CALCUL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("calculate", ())],
    },
};

pub(crate) static CALL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("call", ())],
    },
};

pub(crate) static CANCEL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("cancel", ())],
    },
};

pub(crate) static CAPTUR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("capture", ())],
    },
};

pub(crate) static CHANG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("change", ())],
    },
};

pub(crate) static CHECK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("check", ())],
    },
};

pub(crate) static CLEAN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("clean", ())],
    },
};

pub(crate) static CLEAR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("clear", ())],
    },
};

pub(crate) static CLOSE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("close", ())],
    },
};

pub(crate) static COLLECT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("collect", ())],
    },
};

pub(crate) static COMBIN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("combine", ())],
    },
};

pub(crate) static COMMIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("commit", ())],
    },
};

pub(crate) static COMPAR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("compare", ())],
    },
};

pub(crate) static COMPUT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("compute", ())],
    },
};

pub(crate) static CONFIGUR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("configure", ())],
    },
};

pub(crate) static CONFIRM_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("confirm", ())],
    },
};

pub(crate) static CONNECT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("connect", ())],
    },
};

pub(crate) static CONSTRUCT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("construct", ())],
    },
};

pub(crate) static CONTROL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("control", ())],
    },
};

pub(crate) static CONVERT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("convert", ())],
    },
};

pub(crate) static COPI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("copy", ())],
    },
};

pub(crate) static COUNT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("count", ())],
    },
};

pub(crate) static CREAT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("create", ())],
    },
};

pub(crate) static CUSTOM_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("customize", ())],
    },
};

pub(crate) static DECLAR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("declare", ())],
    },
};

pub(crate) static DECOD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("decode", ())],
    },
};

pub(crate) static DECOR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("decorate", ())],
    },
};

pub(crate) static DEFIN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("define", ())],
    },
};

pub(crate) static DELEG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("delegate", ())],
    },
};

pub(crate) static DELET_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("delete", ())],
    },
};

pub(crate) static DEPREC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("deprecate", ())],
    },
};

pub(crate) static DERIV_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("derive", ())],
    },
};

pub(crate) static DESCRIB_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("describe", ())],
    },
};

pub(crate) static DETECT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("detect", ())],
    },
};

pub(crate) static DETERMIN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("determine", ())],
    },
};

pub(crate) static DISPLAY_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("display", ())],
    },
};

pub(crate) static DOWNLOAD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("download", ())],
    },
};

pub(crate) static DROP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("drop", ())],
    },
};

pub(crate) static DUMP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("dump", ())],
    },
};

pub(crate) static EMIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("emit", ())],
    },
};

pub(crate) static EMPTI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("empty", ())],
    },
};

pub(crate) static ENABL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("enable", ())],
    },
};

pub(crate) static ENCAPSUL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("encapsulate", ())],
    },
};

pub(crate) static ENCOD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("encode", ())],
    },
};

pub(crate) static END_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("end", ())],
    },
};

pub(crate) static ENSUR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("ensure", ())],
    },
};

pub(crate) static ENUMER_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("enumerate", ())],
    },
};

pub(crate) static ESTABLISH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("establish", ())],
    },
};

pub(crate) static EVALU_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("evaluate", ())],
    },
};

pub(crate) static EXAMIN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("examine", ())],
    },
};

pub(crate) static EXECUT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("execute", ())],
    },
};

pub(crate) static EXIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("exit", ())],
    },
};

pub(crate) static EXPAND_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("expand", ())],
    },
};

pub(crate) static EXPECT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("expect", ())],
    },
};

pub(crate) static EXPORT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("export", ())],
    },
};

pub(crate) static EXTEND_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("extend", ())],
    },
};

pub(crate) static EXTRACT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("extract", ())],
    },
};

pub(crate) static FEED_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("feed", ())],
    },
};

pub(crate) static FETCH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("fetch", ())],
    },
};

pub(crate) static FILL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("fill", ())],
    },
};

pub(crate) static FILTER_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("filter", ())],
    },
};

pub(crate) static FINAL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("finalize", ())],
    },
};

pub(crate) static FIND_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("find", ())],
    },
};

pub(crate) static FIRE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("fire", ())],
    },
};

pub(crate) static FIX_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("fix", ())],
    },
};

pub(crate) static FLAG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("flag", ())],
    },
};

pub(crate) static FORC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("force", ())],
    },
};

pub(crate) static FORMAT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("format", ())],
    },
};

pub(crate) static FORWARD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("forward", ())],
    },
};

pub(crate) static GENERAT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("generate", ())],
    },
};

pub(crate) static GET_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("get", ())],
    },
};

pub(crate) static GIVE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("give", ())],
    },
};

pub(crate) static GO_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("go", ())],
    },
};

pub(crate) static GROUP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("group", ())],
    },
};

pub(crate) static HANDL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("handle", ())],
    },
};

pub(crate) static HELP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("help", ())],
    },
};

pub(crate) static HOLD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("hold", ())],
    },
};

pub(crate) static IDENTIFI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("identify", ())],
    },
};

pub(crate) static IMPLEMENT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("implement", ())],
    },
};

pub(crate) static IMPORT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("import", ())],
    },
};

pub(crate) static INDIC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("indicate", ())],
    },
};

pub(crate) static INIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("init", ())],
    },
};

pub(crate) static INITI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 15467950696543387533,
        disps: &[(1, 0)],
        entries: &[("initiate", ()), ("initialize", ())],
    },
};

pub(crate) static INITIALIS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("initialise", ())],
    },
};

pub(crate) static INPUT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("input", ())],
    },
};

pub(crate) static INSERT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("insert", ())],
    },
};

pub(crate) static INSTANTI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("instantiate", ())],
    },
};

pub(crate) static INTERCEPT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("intercept", ())],
    },
};

pub(crate) static INVOK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("invoke", ())],
    },
};

pub(crate) static ITER_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("iterate", ())],
    },
};

pub(crate) static JOIN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("join", ())],
    },
};

pub(crate) static KEEP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("keep", ())],
    },
};

pub(crate) static LAUNCH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("launch", ())],
    },
};

pub(crate) static LIST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("list", ())],
    },
};

pub(crate) static LISTEN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("listen", ())],
    },
};

pub(crate) static LOAD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("load", ())],
    },
};

pub(crate) static LOG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("log", ())],
    },
};

pub(crate) static LOOK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("look", ())],
    },
};

pub(crate) static MAKE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("make", ())],
    },
};

pub(crate) static MANAG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("manage", ())],
    },
};

pub(crate) static MANIPUL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("manipulate", ())],
    },
};

pub(crate) static MAP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("map", ())],
    },
};

pub(crate) static MARK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("mark", ())],
    },
};

pub(crate) static MATCH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("match", ())],
    },
};

pub(crate) static MERG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("merge", ())],
    },
};

pub(crate) static MOCK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("mock", ())],
    },
};

pub(crate) static MODIFI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("modify", ())],
    },
};

pub(crate) static MONITOR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("monitor", ())],
    },
};

pub(crate) static MOVE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("move", ())],
    },
};

pub(crate) static NORMAL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("normalize", ())],
    },
};

pub(crate) static NOTE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("note", ())],
    },
};

pub(crate) static OBTAIN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("obtain", ())],
    },
};

pub(crate) static OPEN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("open", ())],
    },
};

pub(crate) static OUTPUT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("output", ())],
    },
};

pub(crate) static OVERRID_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("override", ())],
    },
};

pub(crate) static OVERWRIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("overwrite", ())],
    },
};

pub(crate) static PACKAG_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("package", ())],
    },
};

pub(crate) static PAD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("pad", ())],
    },
};

pub(crate) static PARS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("parse", ())],
    },
};

pub(crate) static PARTIAL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("partial", ())],
    },
};

pub(crate) static PASS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("pass", ())],
    },
};

pub(crate) static PERFORM_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("perform", ())],
    },
};

pub(crate) static PERSIST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("persist", ())],
    },
};

pub(crate) static PICK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("pick", ())],
    },
};

pub(crate) static PLOT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("plot", ())],
    },
};

pub(crate) static POLL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("poll", ())],
    },
};

pub(crate) static POPUL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("populate", ())],
    },
};

pub(crate) static POST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("post", ())],
    },
};

pub(crate) static PREPAR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("prepare", ())],
    },
};

pub(crate) static PRINT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("print", ())],
    },
};

pub(crate) static PROCESS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("process", ())],
    },
};

pub(crate) static PRODUC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("produce", ())],
    },
};

pub(crate) static PROVID_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("provide", ())],
    },
};

pub(crate) static PUBLISH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("publish", ())],
    },
};

pub(crate) static PULL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("pull", ())],
    },
};

pub(crate) static PUT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("put", ())],
    },
};

pub(crate) static QUERI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("query", ())],
    },
};

pub(crate) static RAIS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("raise", ())],
    },
};

pub(crate) static READ_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("read", ())],
    },
};

pub(crate) static RECORD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("record", ())],
    },
};

pub(crate) static REFER_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("refer", ())],
    },
};

pub(crate) static REFRESH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("refresh", ())],
    },
};

pub(crate) static REGIST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("register", ())],
    },
};

pub(crate) static RELOAD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("reload", ())],
    },
};

pub(crate) static REMOV_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("remove", ())],
    },
};

pub(crate) static RENAM_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("rename", ())],
    },
};

pub(crate) static RENDER_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("render", ())],
    },
};

pub(crate) static REPLAC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("replace", ())],
    },
};

pub(crate) static REPLI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("reply", ())],
    },
};

pub(crate) static REPORT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("report", ())],
    },
};

pub(crate) static REPRES_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("represent", ())],
    },
};

pub(crate) static REQUEST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("request", ())],
    },
};

pub(crate) static REQUIR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("require", ())],
    },
};

pub(crate) static RESET_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("reset", ())],
    },
};

pub(crate) static RESOLV_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("resolve", ())],
    },
};

pub(crate) static RETRIEV_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("retrieve", ())],
    },
};

pub(crate) static RETURN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("return", ())],
    },
};

pub(crate) static ROLL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("roll", ())],
    },
};

pub(crate) static ROLLBACK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("rollback", ())],
    },
};

pub(crate) static ROUND_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("round", ())],
    },
};

pub(crate) static RUN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("run", ())],
    },
};

pub(crate) static SAMPL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("sample", ())],
    },
};

pub(crate) static SAVE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("save", ())],
    },
};

pub(crate) static SCAN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("scan", ())],
    },
};

pub(crate) static SEARCH_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("search", ())],
    },
};

pub(crate) static SELECT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("select", ())],
    },
};

pub(crate) static SEND_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("send", ())],
    },
};

pub(crate) static SERIAL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("serialize", ())],
    },
};

pub(crate) static SERIALIS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("serialise", ())],
    },
};

pub(crate) static SERV_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("serve", ())],
    },
};

pub(crate) static SET_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("set", ())],
    },
};

pub(crate) static SHOW_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("show", ())],
    },
};

pub(crate) static SIMUL_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("simulate", ())],
    },
};

pub(crate) static SOURC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("source", ())],
    },
};

pub(crate) static SPECIFI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("specify", ())],
    },
};

pub(crate) static SPLIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("split", ())],
    },
};

pub(crate) static START_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("start", ())],
    },
};

pub(crate) static STEP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("step", ())],
    },
};

pub(crate) static STOP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("stop", ())],
    },
};

pub(crate) static STORE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("store", ())],
    },
};

pub(crate) static STRIP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("strip", ())],
    },
};

pub(crate) static SUBMIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("submit", ())],
    },
};

pub(crate) static SUBSCRIB_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("subscribe", ())],
    },
};

pub(crate) static SUM_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("sum", ())],
    },
};

pub(crate) static SWAP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("swap", ())],
    },
};

pub(crate) static SYNC_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("sync", ())],
    },
};

pub(crate) static SYNCHRON_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("synchronize", ())],
    },
};

pub(crate) static SYNCHRONIS_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("synchronise", ())],
    },
};

pub(crate) static TAKE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("take", ())],
    },
};

pub(crate) static TEAR_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("tear", ())],
    },
};

pub(crate) static TEST_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("test", ())],
    },
};

pub(crate) static TIME_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("time", ())],
    },
};

pub(crate) static TRANSFORM_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("transform", ())],
    },
};

pub(crate) static TRANSLAT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("translate", ())],
    },
};

pub(crate) static TRANSMIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("transmit", ())],
    },
};

pub(crate) static TRI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("try", ())],
    },
};

pub(crate) static TRUNCAT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("truncate", ())],
    },
};

pub(crate) static TURN_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("turn", ())],
    },
};

pub(crate) static TWEAK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("tweak", ())],
    },
};

pub(crate) static UPDAT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("update", ())],
    },
};

pub(crate) static UPLOAD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("upload", ())],
    },
};

pub(crate) static USE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("use", ())],
    },
};

pub(crate) static VALID_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("validate", ())],
    },
};

pub(crate) static VERIFI_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("verify", ())],
    },
};

pub(crate) static VIEW_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("view", ())],
    },
};

pub(crate) static WAIT_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("wait", ())],
    },
};

pub(crate) static WALK_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("walk", ())],
    },
};

pub(crate) static WRAP_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("wrap", ())],
    },
};

pub(crate) static WRITE_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("write", ())],
    },
};

pub(crate) static YIELD_STEM: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 12913932095322966823,
        disps: &[(0, 0)],
        entries: &[("yield", ())],
    },
};

pub(crate) static IMPERATIVES: phf::Map<&'static str, &phf::Set<&'static str>> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 97),
        (0, 22),
        (0, 1),
        (0, 168),
        (0, 127),
        (1, 84),
        (0, 11),
        (0, 76),
        (2, 115),
        (0, 82),
        (0, 1),
        (1, 0),
        (8, 40),
        (8, 224),
        (0, 164),
        (1, 216),
        (2, 186),
        (0, 4),
        (0, 143),
        (0, 1),
        (0, 18),
        (0, 24),
        (0, 100),
        (1, 179),
        (0, 3),
        (10, 167),
        (2, 22),
        (34, 159),
        (0, 2),
        (1, 39),
        (0, 10),
        (0, 2),
        (0, 118),
        (0, 40),
        (0, 37),
        (0, 14),
        (1, 69),
        (7, 57),
        (0, 74),
        (1, 169),
        (5, 41),
        (6, 114),
        (0, 104),
        (19, 118),
        (0, 0),
        (18, 138),
    ],
    entries: &[
        ("send", &SEND_STEM),
        ("pull", &PULL_STEM),
        ("perform", &PERFORM_STEM),
        ("test", &TEST_STEM),
        ("creat", &CREAT_STEM),
        ("match", &MATCH_STEM),
        ("refresh", &REFRESH_STEM),
        ("post", &POST_STEM),
        ("serial", &SERIAL_STEM),
        ("exit", &EXIT_STEM),
        ("upload", &UPLOAD_STEM),
        ("generat", &GENERAT_STEM),
        ("captur", &CAPTUR_STEM),
        ("show", &SHOW_STEM),
        ("get", &GET_STEM),
        ("insert", &INSERT_STEM),
        ("input", &INPUT_STEM),
        ("manipul", &MANIPUL_STEM),
        ("encapsul", &ENCAPSUL_STEM),
        ("search", &SEARCH_STEM),
        ("read", &READ_STEM),
        ("pass", &PASS_STEM),
        ("sync", &SYNC_STEM),
        ("chang", &CHANG_STEM),
        ("log", &LOG_STEM),
        ("rollback", &ROLLBACK_STEM),
        ("process", &PROCESS_STEM),
        ("feed", &FEED_STEM),
        ("print", &PRINT_STEM),
        ("sum", &SUM_STEM),
        ("popul", &POPUL_STEM),
        ("renam", &RENAM_STEM),
        ("monitor", &MONITOR_STEM),
        ("defin", &DEFIN_STEM),
        ("fire", &FIRE_STEM),
        ("ensur", &ENSUR_STEM),
        ("translat", &TRANSLAT_STEM),
        ("custom", &CUSTOM_STEM),
        ("merg", &MERG_STEM),
        ("roll", &ROLL_STEM),
        ("fill", &FILL_STEM),
        ("delet", &DELET_STEM),
        ("enumer", &ENUMER_STEM),
        ("append", &APPEND_STEM),
        ("check", &CHECK_STEM),
        ("authent", &AUTHENT_STEM),
        ("assert", &ASSERT_STEM),
        ("view", &VIEW_STEM),
        ("determin", &DETERMIN_STEM),
        ("mark", &MARK_STEM),
        ("encod", &ENCOD_STEM),
        ("go", &GO_STEM),
        ("convert", &CONVERT_STEM),
        ("queri", &QUERI_STEM),
        ("yield", &YIELD_STEM),
        ("remov", &REMOV_STEM),
        ("poll", &POLL_STEM),
        ("allow", &ALLOW_STEM),
        ("tear", &TEAR_STEM),
        ("step", &STEP_STEM),
        ("select", &SELECT_STEM),
        ("expand", &EXPAND_STEM),
        ("pick", &PICK_STEM),
        ("overrid", &OVERRID_STEM),
        ("submit", &SUBMIT_STEM),
        ("extend", &EXTEND_STEM),
        ("appli", &APPLI_STEM),
        ("count", &COUNT_STEM),
        ("invok", &INVOK_STEM),
        ("construct", &CONSTRUCT_STEM),
        ("call", &CALL_STEM),
        ("access", &ACCESS_STEM),
        ("repres", &REPRES_STEM),
        ("join", &JOIN_STEM),
        ("adjust", &ADJUST_STEM),
        ("listen", &LISTEN_STEM),
        ("pad", &PAD_STEM),
        ("render", &RENDER_STEM),
        ("put", &PUT_STEM),
        ("init", &INIT_STEM),
        ("clear", &CLEAR_STEM),
        ("serv", &SERV_STEM),
        ("return", &RETURN_STEM),
        ("archiv", &ARCHIV_STEM),
        ("provid", &PROVID_STEM),
        ("subscrib", &SUBSCRIB_STEM),
        ("pars", &PARS_STEM),
        ("note", &NOTE_STEM),
        ("map", &MAP_STEM),
        ("control", &CONTROL_STEM),
        ("give", &GIVE_STEM),
        ("run", &RUN_STEM),
        ("updat", &UPDAT_STEM),
        ("emit", &EMIT_STEM),
        ("execut", &EXECUT_STEM),
        ("accept", &ACCEPT_STEM),
        ("calcul", &CALCUL_STEM),
        ("verifi", &VERIFI_STEM),
        ("filter", &FILTER_STEM),
        ("sourc", &SOURC_STEM),
        ("resolv", &RESOLV_STEM),
        ("look", &LOOK_STEM),
        ("scan", &SCAN_STEM),
        ("partial", &PARTIAL_STEM),
        ("make", &MAKE_STEM),
        ("load", &LOAD_STEM),
        ("repli", &REPLI_STEM),
        ("dump", &DUMP_STEM),
        ("fetch", &FETCH_STEM),
        ("break", &BREAK_STEM),
        ("group", &GROUP_STEM),
        ("strip", &STRIP_STEM),
        ("normal", &NORMAL_STEM),
        ("split", &SPLIT_STEM),
        ("wrap", &WRAP_STEM),
        ("take", &TAKE_STEM),
        ("swap", &SWAP_STEM),
        ("list", &LIST_STEM),
        ("import", &IMPORT_STEM),
        ("cancel", &CANCEL_STEM),
        ("author", &AUTHOR_STEM),
        ("keep", &KEEP_STEM),
        ("tweak", &TWEAK_STEM),
        ("retriev", &RETRIEV_STEM),
        ("store", &STORE_STEM),
        ("report", &REPORT_STEM),
        ("transmit", &TRANSMIT_STEM),
        ("help", &HELP_STEM),
        ("synchronis", &SYNCHRONIS_STEM),
        ("connect", &CONNECT_STEM),
        ("collect", &COLLECT_STEM),
        ("copi", &COPI_STEM),
        ("deriv", &DERIV_STEM),
        ("rais", &RAIS_STEM),
        ("round", &ROUND_STEM),
        ("specifi", &SPECIFI_STEM),
        ("start", &START_STEM),
        ("end", &END_STEM),
        ("clean", &CLEAN_STEM),
        ("implement", &IMPLEMENT_STEM),
        ("refer", &REFER_STEM),
        ("attempt", &ATTEMPT_STEM),
        ("valid", &VALID_STEM),
        ("deleg", &DELEG_STEM),
        ("expect", &EXPECT_STEM),
        ("iter", &ITER_STEM),
        ("enabl", &ENABL_STEM),
        ("synchron", &SYNCHRON_STEM),
        ("record", &RECORD_STEM),
        ("initialis", &INITIALIS_STEM),
        ("find", &FIND_STEM),
        ("turn", &TURN_STEM),
        ("initi", &INITI_STEM),
        ("set", &SET_STEM),
        ("request", &REQUEST_STEM),
        ("cach", &CACH_STEM),
        ("time", &TIME_STEM),
        ("fix", &FIX_STEM),
        ("modifi", &MODIFI_STEM),
        ("examin", &EXAMIN_STEM),
        ("export", &EXPORT_STEM),
        ("sampl", &SAMPL_STEM),
        ("flag", &FLAG_STEM),
        ("requir", &REQUIR_STEM),
        ("mock", &MOCK_STEM),
        ("regist", &REGIST_STEM),
        ("evalu", &EVALU_STEM),
        ("move", &MOVE_STEM),
        ("plot", &PLOT_STEM),
        ("decor", &DECOR_STEM),
        ("handl", &HANDL_STEM),
        ("prepar", &PREPAR_STEM),
        ("display", &DISPLAY_STEM),
        ("publish", &PUBLISH_STEM),
        ("simul", &SIMUL_STEM),
        ("obtain", &OBTAIN_STEM),
        ("extract", &EXTRACT_STEM),
        ("comput", &COMPUT_STEM),
        ("build", &BUILD_STEM),
        ("instanti", &INSTANTI_STEM),
        ("wait", &WAIT_STEM),
        ("declar", &DECLAR_STEM),
        ("manag", &MANAG_STEM),
        ("add", &ADD_STEM),
        ("identifi", &IDENTIFI_STEM),
        ("detect", &DETECT_STEM),
        ("empti", &EMPTI_STEM),
        ("format", &FORMAT_STEM),
        ("use", &USE_STEM),
        ("produc", &PRODUC_STEM),
        ("save", &SAVE_STEM),
        ("hold", &HOLD_STEM),
        ("decod", &DECOD_STEM),
        ("write", &WRITE_STEM),
        ("open", &OPEN_STEM),
        ("combin", &COMBIN_STEM),
        ("close", &CLOSE_STEM),
        ("forc", &FORC_STEM),
        ("transform", &TRANSFORM_STEM),
        ("configur", &CONFIGUR_STEM),
        ("replac", &REPLAC_STEM),
        ("stop", &STOP_STEM),
        ("serialis", &SERIALIS_STEM),
        ("aggreg", &AGGREG_STEM),
        ("intercept", &INTERCEPT_STEM),
        ("tri", &TRI_STEM),
        ("deprec", &DEPREC_STEM),
        ("drop", &DROP_STEM),
        ("overwrit", &OVERWRIT_STEM),
        ("packag", &PACKAG_STEM),
        ("reset", &RESET_STEM),
        ("final", &FINAL_STEM),
        ("establish", &ESTABLISH_STEM),
        ("output", &OUTPUT_STEM),
        ("describ", &DESCRIB_STEM),
        ("confirm", &CONFIRM_STEM),
        ("reload", &RELOAD_STEM),
        ("persist", &PERSIST_STEM),
        ("indic", &INDIC_STEM),
        ("launch", &LAUNCH_STEM),
        ("truncat", &TRUNCAT_STEM),
        ("forward", &FORWARD_STEM),
        ("assign", &ASSIGN_STEM),
        ("compar", &COMPAR_STEM),
        ("commit", &COMMIT_STEM),
        ("walk", &WALK_STEM),
        ("download", &DOWNLOAD_STEM),
    ],
};
pub(crate) static BLACKLIST: phf::Set<&'static str> = ::phf::Set {
    map: ::phf::Map {
        key: 15467950696543387533,
        disps: &[
            (0, 0),
            (0, 23),
            (0, 32),
            (2, 0),
            (4, 54),
            (0, 5),
            (0, 0),
            (0, 0),
            (36, 61),
            (0, 22),
            (3, 71),
            (2, 55),
            (0, 24),
            (50, 52),
            (0, 5),
        ],
        entries: &[
            ("api", ()),
            ("unique", ()),
            ("implementation", ()),
            ("data", ()),
            ("static", ()),
            ("number", ()),
            ("standard", ()),
            ("placeholder", ()),
            ("should", ()),
            ("calculation", ()),
            ("example", ()),
            ("callback", ()),
            ("these", ()),
            ("custom", ()),
            ("that", ()),
            ("string", ()),
            ("base", ()),
            ("method", ()),
            ("module", ()),
            ("default", ()),
            ("dict", ()),
            ("a", ()),
            ("same", ()),
            ("some", ()),
            ("deprecated", ()),
            ("current", ()),
            ("true", ()),
            ("simple", ()),
            ("the", ()),
            ("subclasses", ()),
            ("always", ()),
            ("currently", ()),
            ("what", ()),
            ("handler", ()),
            ("description", ()),
            ("formula", ()),
            ("convenience", ()),
            ("helper", ()),
            ("hook", ()),
            ("basic", ()),
            ("optional", ()),
            ("special", ()),
            ("setup", ()),
            ("new", ()),
            ("wrapper", ()),
            ("convenient", ()),
            ("utility", ()),
            ("false", ()),
            ("reference", ()),
            ("this", ()),
            ("unit", ()),
            ("an", ()),
            ("here", ()),
            ("common", ()),
            ("dictionary", ()),
            ("does", ()),
            ("factory", ()),
            ("constructor", ()),
            ("function", ()),
            ("internal", ()),
            ("dummy", ()),
            ("sql", ()),
            ("action", ()),
            ("it", ()),
            ("collection", ()),
            ("schema", ()),
            ("generic", ()),
            ("importantly", ()),
            ("final", ()),
            ("main", ()),
            ("business", ()),
            ("result", ()),
        ],
    },
};