diff --git a/crates/typos-dict/assets/words.csv b/crates/typos-dict/assets/words.csv index 347a4a5..f23ac08 100644 --- a/crates/typos-dict/assets/words.csv +++ b/crates/typos-dict/assets/words.csv @@ -1,39 +1,86 @@ +aaccessibility,accessibility +aaccession,accession +aack,ack +aactual,actual +aactually,actually +aadd,add +aaggregation,aggregation +aanother,another +aapply,apply +aare,are +aassociated,associated +aautomatic,automatic +aautomatically,automatically +abailable,available +abanden,abandon abandenment,abandonment abandining,abandoning abandomnent,abandonment abandond,abandoned +abandonded,abandoned abandonding,abandoning +abandone,abandon abandonig,abandoning abandonne,abandonment abandonned,abandoned abandonnent,abandonment abandonning,abandoning abanonded,abandoned +abbbreviated,abbreviated +abberation,aberration +abberations,aberrations +abberivates,abbreviates abberivation,abbreviation +abberration,aberration abberviation,abbreviation -abbout,about +abbort,abort,abbot +abborted,aborted +abborting,aborting +abborts,aborts,abbots +abbout,about,abbot abbreivation,abbreviation +abbrevate,abbreviate +abbrevation,abbreviation +abbrevations,abbreviations abbreveation,abbreviation abbreviatin,abbreviation abbreviato,abbreviation abbreviaton,abbreviation +abbreviatons,abbreviations abbrievation,abbreviation abbrievations,abbreviation +abbriviate,abbreviate +abbriviation,abbreviation +abbriviations,abbreviations abdominable,abdominal abdomine,abdomen abdomnial,abdominal abdonimal,abdominal aberation,aberration +abigious,ambiguous +abiguity,ambiguity abilitiy,ability +abilityes,abilities abilties,abilities abiltiy,ability abilty,ability +abiss,abyss +abitrarily,arbitrarily +abitrate,arbitrate +abitration,arbitration +abizmal,abysmal abnoramlly,abnormally abnormalty,abnormally abnormaly,abnormally abnornally,abnormally +abnove,above +abnrormal,abnormal +aboce,above,abode abodmen,abdomen abodminal,abdominal +aboluste,absolute +abolustely,absolutely +abolute,absolute abomanation,abomination abominacion,abomination abominaton,abomination @@ -43,6 +90,8 @@ abondoned,abandoned abondoning,abandoning abondons,abandons abonimation,abomination +aboout,about +abord,abort,aboard aborginial,aboriginal aboriganal,aboriginal aborigenal,aboriginal @@ -52,6 +101,7 @@ aborigional,aboriginal aborignial,aboriginal aborigonal,aboriginal aboroginal,aboriginal +aborte,aborted,abort,aborts abortificant,abortifacient aboslute,absolute aboslutely,absolutely @@ -61,14 +111,31 @@ abosrbed,absorbed abosrbing,absorbing abosrbs,absorbs abosrption,absorption +abosulte,absolute +abosultely,absolutely +abosulute,absolute +abosulutely,absolutely abotu,about +abount,about +abourt,abort,about +abouta,about +abouve,above +abov,above +aboved,above +abovemtioned,abovementioned +aboves,above +abovmentioned,abovementioned abreviate,abbreviate abreviated,abbreviated +abreviates,abbreviates +abreviating,abbreviating abreviation,abbreviation +abreviations,abbreviations abriter,arbiter abritrarily,arbitrarily abritrary,arbitrary abritration,arbitration +abriviate,abbreviate abrreviation,abbreviation abruplty,abruptly abruptley,abruptly @@ -76,59 +143,176 @@ abrupty,abruptly abrutply,abruptly absail,abseil absailing,abseiling +absance,absence abscence,absence +abscound,abscond +abselutely,absolutely +abselutly,absolutely absense,absence absestos,asbestos absintence,abstinence absitnence,abstinence absloutes,absolutes +absodefly,absolute +absodeflyly,absolutely +absolate,absolute +absolately,absolutely +absolaute,absolute +absolautely,absolutely +absolete,absolute,obsolete +absoleted,obsoleted +absoletely,absolutely +absoliute,absolute +absoliutely,absolutely +absoloute,absolute +absoloutely,absolutely +absolte,absolute +absoltely,absolutely +absoltue,absolute +absoltuely,absolutely +absoluate,absolute +absoluately,absolutely absolue,absolute +absoluely,absolutely +absoluet,absolute +absoluetly,absolutely +absolulte,absolute +absolultely,absolutely absolument,absolute +absolune,absolute +absolunely,absolutely +absolure,absolute +absolurely,absolutely +absolut,absolute absolutelly,absolutely absolutelys,absolutes absolutey,absolutely +absoluth,absolute +absoluthe,absolute +absoluthely,absolutely +absoluthly,absolutely absolutisme,absolutes absolutiste,absolutes absolutley,absolutely absolutly,absolutely +absolutlye,absolutely absoluts,absolutes +absoluute,absolute +absoluutely,absolutely +absoluve,absolute +absoluvely,absolutely absolvte,absolve +absoolute,absolute +absoolutely,absolutely absoprtion,absorption +absorbant,absorbent absorbes,absorbs absorbsion,absorption absorbtion,absorption absorpsion,absorption +absorve,absorb +absould,absolute +absouldly,absolutely +absoule,absolute +absoulely,absolutely +absoulete,absolute,obsolete +absouletely,absolutely +absoult,absolute absoulte,absolute absoultely,absolutely absoultes,absolutes +absoultly,absolutely +absoulute,absolute +absoulutely,absolutely +absout,absolute +absoute,absolute +absoutely,absolutely +absoutly,absolutely absovle,absolve absrobs,absorbs +abstact,abstract +abstacted,abstracted +abstacter,abstracter +abstacting,abstracting +abstaction,abstraction +abstactions,abstractions +abstactly,abstractly +abstactness,abstractness +abstactor,abstractor +abstacts,abstracts abstanence,abstinence abstante,bastante abstenance,abstinence abstenince,abstinence abstinense,abstinence abstinince,abstinence +abstrac,abstract abstraccion,abstraction +abstraced,abstracted +abstracer,abstracter +abstracing,abstracting +abstracion,abstraction +abstracions,abstractions +abstracly,abstractly +abstracness,abstractness +abstracor,abstractor +abstracs,abstracts abstracto,abstraction abstraktion,abstraction +abstrat,abstract +abstrated,abstracted +abstrater,abstracter +abstrating,abstracting +abstration,abstraction +abstrations,abstractions +abstratly,abstractly +abstratness,abstractness +abstrator,abstractor +abstrats,abstracts +abstrct,abstract +abstrcted,abstracted +abstrcter,abstracter +abstrcting,abstracting +abstrction,abstraction +abstrctions,abstractions +abstrctly,abstractly +abstrctness,abstractness +abstrctor,abstractor +abstrcts,abstracts abstruction,abstraction absuers,abusers +absulute,absolute absurditiy,absurdity absurdley,absurdly absurdy,absurdly absuridty,absurdity absymal,abysmal +abtract,abstract +abtracted,abstracted +abtracter,abstracter +abtracting,abstracting +abtraction,abstraction +abtractions,abstractions +abtractly,abstractly +abtractness,abstractness +abtractor,abstractor +abtracts,abstracts abudance,abundance +abudances,abundances abudcted,abducted abundacies,abundances abundancies,abundances +abundand,abundant +abundence,abundance +abundent,abundant abundunt,abundant aburptly,abruptly abuseres,abusers abusrdity,absurdity abusrdly,absurdly abutts,abuts +abvailable,available +abvious,obvious abymsal,abysmal acadamy,academy academcially,academically @@ -139,19 +323,60 @@ academicese,academics academicos,academics academicus,academics academis,academics +acadimy,academy acadmic,academic +acale,scale +acatemy,academy accademic,academic accademy,academy accalimed,acclaimed +accapt,accept +accapted,accepted +accapts,accepts +acccept,accept +acccepted,accepted +acccepting,accepting +acccepts,accepts +accces,access +acccess,access +acccessd,accessed +acccessed,accessed +acccesses,accesses +acccessibility,accessibility +acccessible,accessible +acccessing,accessing +acccession,accession +acccessor,accessor +acccessors,accessors +acccord,accord +acccordance,accordance +acccordances,accordances +acccorded,accorded +acccording,according +acccordingly,accordingly +acccords,accords +acccount,account +acccumulate,accumulate +acccuracy,accuracy +acccurate,accurate +acccurately,accurately acccused,accused accdiently,accidently +accecpted,accepted accedentally,accidentally +accees,access +acceess,access accelarate,accelerate accelarated,accelerated accelarating,accelerating accelaration,acceleration accelarator,accelerator +accelearte,accelerate +accelearted,accelerated +acceleartes,accelerates acceleartion,acceleration +acceleartor,accelerator +acceleated,accelerated accelerade,accelerated acceleraptor,accelerator accelerar,accelerator @@ -160,16 +385,23 @@ accelerater,accelerator acceleratie,accelerate acceleratio,accelerator accelerato,acceleration +acceleratoin,acceleration acceleraton,acceleration +acceleratrion,acceleration acceleread,accelerated accelertor,accelerator +accellerated,accelerated accelleration,acceleration accelorate,accelerate accelorated,accelerated accelorating,accelerating accelorator,accelerator accending,ascending -accension,accession +accension,accession,ascension +accepatble,acceptable +accepect,accept +accepected,accepted +acceppt,accept acceptabel,acceptable acceptabelt,acceptable acceptabil,acceptable @@ -178,18 +410,51 @@ accepterad,accepted acceptes,accepts acceptible,acceptable accerelate,accelerated +acces,access +accesed,accessed +acceses,accesses +accesibility,accessibility +accesible,accessible +accesing,accessing +accesnt,accent +accesor,accessor accesories,accessories +accesors,accessors +accesory,accessory accessable,accessible accessbile,accessible accesseries,accessories accessibile,accessible +accessibiliity,accessibility +accessibiliy,accessibility,accessible accessibilty,accessibility accessibily,accessibility -accessoire,accessories -accessoires,accessories +accessiblilty,accessibility +accessile,accessible +accessintg,accessing +accessisble,accessible +accessoire,accessories,accessory +accessoires,accessories,accessorise +accessoirez,accessorize,accessories accessoirs,accessories +accessort,accessor accesss,access +accesssor,accessor +accesssors,accessors +accet,accept +accetable,acceptable +accets,accepts +acchiev,achieve +acchievable,achievable +acchieve,achieve +acchieveable,achievable +acchieved,achieved +acchievement,achievement +acchievements,achievements +acchiever,achiever +acchieves,achieves accicently,accidentally +accidant,accident accidantely,accidentally accidantly,accidentally accidebtly,accidentally @@ -199,18 +464,41 @@ accidentaly,accidentally accidentely,accidentally accidentes,accidents accidential,accidental +accidentially,accidentally +accidentically,accidentally accidentily,accidentally accidentky,accidentally accidentlaly,accidentally accidentlay,accidentally accidentley,accidentally accidentlly,accidentally +accidentually,accidentally accidenty,accidentally accideny,accidentally +accidetly,accidentally accidnetly,accidentally +acciedential,accidental +acciednetally,accidentally +accient,accident +acciental,accidental acclamied,acclaimed +acclerated,accelerated +acclerates,accelerates +accleration,acceleration +acclerometers,accelerometers accliamed,acclaimed acclimitization,acclimatization +accoding,according +accodingly,accordingly +accodr,accord +accodrance,accordance +accodred,accorded +accodring,according +accodringly,accordingly +accodrs,accords +accointing,accounting +accoird,accord +accoirding,according accomadate,accommodate accomadated,accommodated accomadates,accommodates @@ -219,10 +507,13 @@ accomadation,accommodation accomadations,accommodations accomdate,accommodate accommadate,accommodate +accommadates,accommodates accommadating,accommodating accommadation,accommodation +accommdated,accommodated accommidate,accommodate accommidation,accommodation +accomodata,accommodate accomodate,accommodate accomodated,accommodated accomodates,accommodates @@ -232,6 +523,13 @@ accomodations,accommodations accomondate,accommodate accomondating,accommodating accomondation,accommodation +accompagned,accompanied +accompagnied,accompanied +accompagnies,accompanies +accompagniment,accompaniment +accompagning,accompanying +accompagny,accompany +accompagnying,accompanying accompained,accompanied accompanyed,accompanied accompianed,accompanied @@ -247,12 +545,39 @@ accomplishents,accomplishes accomplishs,accomplishes accompliss,accomplishes accomponied,accompanied +accompt,account +acconding,according acconplishment,accomplishment +accont,account +accontant,accountant +acconted,accounted +acconting,accounting +accoording,according +accoordingly,accordingly +accordding,according accordeon,accordion accordian,accordion +accordign,according +accordinag,according +accordinly,accordingly +accordint,according +accordintly,accordingly +accordling,according +accordlingly,accordingly +accordng,according +accordngly,accordingly +accoriding,according accoridng,according -accoring,according +accoridngly,accordingly +accoring,according,occurring +accoringly,accordingly +accorndingly,accordingly +accort,accord +accortance,accordance +accorted,accorded +accorting,according accostumed,accustomed +accound,account accountabillity,accountability accountabilty,accountability accountas,accountants @@ -262,18 +587,44 @@ accountent,accountant accountents,accountants accountt,accountant accoustic,acoustic +accoustically,acoustically +accout,account +accouting,accounting +accoutn,account +accpet,accept accpetable,acceptable accpetance,acceptance accpeted,accepted accpets,accepts accquainted,acquainted +accquire,acquire +accquired,acquired +accquires,acquires +accquiring,acquiring +accracy,accuracy +accrate,accurate +accrding,according +accrdingly,accordingly accrediated,accredited accrediation,accreditation accredidation,accreditation accreditied,accredited accreditted,accredited +accress,access +accreting,accrediting accroding,according +accrodingly,accordingly +accronym,acronym +accronyms,acronyms +accrording,according +accros,across +accrose,across accross,across +accsess,access +accss,access +accssible,accessible +accssor,accessor +acctual,actual accuarcy,accuracy accuastion,accusation acculumate,accumulate @@ -282,30 +633,80 @@ acculumation,accumulation accumalate,accumulate accumalated,accumulated accumalation,accumulation +accumalator,accumulator +accumalte,accumulate +accumalted,accumulated accumelate,accumulate accumelated,accumulated accumilate,accumulate accumilated,accumulated accumilation,accumulation +accumlate,accumulate +accumlated,accumulated +accumlates,accumulates +accumlating,accumulating +accumlator,accumulator +accummulating,accumulating +accummulators,accumulators +accumualte,accumulate +accumualtion,accumulation accumulare,accumulate accumulatin,accumulation accumulato,accumulation accumulaton,accumulation accumule,accumulate accumulted,accumulated +accupied,occupied +accupts,accepts +accurable,accurate +accuraccies,accuracies accuraccy,accuracy +accurancy,accuracy +accurarcy,accuracy +accurary,accuracy,actuary accuratelly,accurately accuratley,accurately -accuray,accuracy +accuratly,accurately +accuray,accuracy,actuary +accure,accrue,occur,acquire +accured,accrued,occurred,acquired +accurences,occurrences +accurracy,accuracy +accurring,occurring +accurs,accurse,occurs accusating,accusation accusato,accusation accusition,accusation accussed,accused accustommed,accustomed accustumed,accustomed +acdept,accept,adept +acditionally,additionally +acecess,access acedamia,academia acedemic,academic acedemically,academically +acelerated,accelerated +acend,ascend +acendance,ascendance +acendancey,ascendancy +acended,ascended +acendence,ascendence +acendencey,ascendency +acendency,ascendency +acender,ascender +acending,ascending +acent,ascent +aceptable,acceptable +acerage,acreage +acess,access +acessable,accessible +acessed,accessed +acesses,accesses +acessible,accessible +acessing,accessing +acessor,accessor +acessors,accessors,accessor acftually,factually acheivable,achievable acheive,achieve @@ -332,16 +733,44 @@ achillees,achilles achilleos,achilles achilleous,achilles achilleus,achilles -achive,achieve +achitecture,architecture +achitectures,architectures +achivable,achievable +achive,achieve,archive achiveable,achievable -achived,achieved +achived,achieved,archived achiveing,achieving achivement,achievement achivements,achievements +achiver,achiever,archiver +achives,achieves,archives +achiving,achieving,archiving +achor,anchor +achored,anchored +achoring,anchoring +achors,anchors +aci,acpi acident,accident +acient,ancient +acii,ascii +acition,action +acitions,actions +acitivate,activate +acitivation,activation +acitivity,activity +acitvate,activate acitvates,activates acitvating,activating +acitve,active acitvision,activision +acivate,activate +acive,active +acknodledgment,acknowledgment +acknoledge,acknowledge +acknoledged,acknowledged +acknoledges,acknowledges +acknoledging,acknowledging +acknoledgment,acknowledgment acknolwedge,acknowledge acknolwedged,acknowledged acknolwedgement,acknowledgement @@ -368,23 +797,48 @@ acknowlegdement,acknowledgement acknowlegdes,acknowledges acknowlegding,acknowledging acknowlege,acknowledge -acknowleged,acknowledge +acknowleged,acknowledge,acknowledged acknowleges,acknowledges +acknowleging,acknowledging acknwoledge,acknowledges +ackowledge,acknowledge +ackowledged,acknowledged +ackowledgement,acknowledgement +ackowledges,acknowledges +ackowledging,acknowledging ackumulation,accumulation -ackward,awkward +ackward,awkward,backward aclhemist,alchemist +acn,can,acne acnedote,anecdote +acnowledge,acknowledge +acocunt,account acommodate,accommodate +acommodated,accommodated +acommodates,accommodates +acommodating,accommodating +acommodation,accommodation +acommpany,accompany +acommpanying,accompanying +acomodate,accommodate +acomodated,accommodated +acompanies,accompanies acomplish,accomplish acomplished,accomplished acomplishment,accomplishment acomplishments,accomplishments +acoording,according +acoordingly,accordingly acopalypse,apocalypse acopalyptic,apocalyptic acording,according acordingly,accordingly +acordinng,according acornyms,acronyms +acorss,across +acorting,according +acount,account +acounts,accounts acousitc,acoustic acoutsic,acoustic acovados,avocados @@ -406,34 +860,55 @@ acquiantances,acquaintances acquianted,acquainted acquiantence,acquaintance acquiantences,acquaintances +acquiesence,acquiescence acquifer,acquire acquinated,acquainted acquisation,acquisition acquisito,acquisition acquisiton,acquisition acquited,acquitted +acqure,acquire +acqured,acquired +acqures,acquires acquried,acquired +acquries,acquires,equerries +acquring,acquiring +acrage,acreage acrlyic,acrylic acronmys,acronyms acronymes,acronyms acronymns,acronyms acronysm,acronyms acroynms,acronyms +acrued,accrued acrynoms,acronyms acsended,ascended acsending,ascending acsension,ascension +acses,cases,access +acssumed,assumed +actally,actually +actaul,actual actaully,actually actauly,actually +actial,actual +actibity,activity acticating,activating actication,activation +actine,active +actiual,actual +activ,active activacion,activation +activaed,activated activaste,activates activateing,activating activaters,activates activatin,activation activationg,activating +actived,activated activelly,actively +activeta,activate +activete,activate activiates,activist activiites,activist activisim,activism @@ -446,70 +921,180 @@ activistion,activision activit,activist activite,activities activites,activities +activiti,activity,activities activiting,activating +activitis,activities +activitiy,activity activits,activities activizion,activision activley,actively activly,actively +activtes,activates +activties,activities +activty,activity +activw,active +actove,active actresess,actresses actresss,actresses +actuaal,actual +actuaally,actually +actuak,actual +actuakly,actually actualey,actually actualiy,actuality actualky,actually +actuall,actually,actual +actuallin,actually actualmy,actually actualoy,actually actualpy,actually actualty,actually actualy,actually +actualyl,actually +actuell,actual +actuion,action +actuionable,actionable +actul,actual actulay,actually +actullay,actually +actully,actually +acturally,actually +actusally,actually +actzal,actual +acual,actual +acually,actually +acuired,acquired +acuires,acquires +acumulate,accumulate +acumulated,accumulated +acumulates,accumulates +acumulating,accumulating +acumulation,accumulation +acumulative,accumulative +acumulator,accumulator +acuqire,acquire acuracy,accuracy +acurate,accurate acusation,causation acused,accused acusing,causing acustom,accustom acustommed,accustomed +acutal,actual acutality,actuality acutally,actually acutaly,actually acutions,auctions +acutual,actual acyrlic,acrylic +adapated,adapted +adapater,adapter +adapaters,adapters +adapd,adapt,adapted,adopt,adopted +adapdive,adaptive +adaped,adapted,adapt,adopted,adopt +adapive,adaptive adaptacion,adaptation +adaptaion,adaptation adaptare,adapter adaptating,adaptation +adapte,adapter +adaptee,adapted adaptes,adapters +adaptibe,adaptive +adaptove,adaptive,adoptive +adaquate,adequate +adaquately,adequately adaquetely,adequately adatper,adapter +adatpers,adapters +adavance,advance adavanced,advanced adbandon,abandon adbomen,abdomen adbominal,abdominal adbucted,abducted +addapt,adapt +addaptation,adaptation +addaptations,adaptations +addapted,adapted +addapting,adapting +addapts,adapts addcits,addicts +addd,add +addded,added +addding,adding +adddress,address +adddresses,addresses +addds,adds +addedd,added +addeed,added adderss,address +addersses,addresses +addert,assert +adderted,asserted +addes,adds,added +addess,address +addessed,addressed +addesses,addresses +addessing,addressing addicitons,addictions addictes,addicts addictin,addictions addictis,addictions +addied,added +addig,adding addional,additional addionally,additionally +additianally,additionally additinally,additionally +additioanlly,additionally +additiona,additional +additionallly,additionally additionaly,additionally +additionalyy,additionally +additionnal,additional +additionnally,additionally +additionnaly,additionally additivies,additive additivley,additive +additon,addition additonal,additional additonally,additionally +additonaly,additionally addittions,addictions +addjust,adjust +addjusted,adjusted +addjusting,adjusting +addjusts,adjusts addmission,admission +addmit,admit addopt,adopt addopted,adopted -addoptive,adoptive +addoptive,adoptive,adaptive +addpress,address +addrass,address +addrees,address +addreess,address addres,address addresable,addressable addresed,addressed +addreses,addresses +addresess,addresses addresing,addressing +addresse,addresses,address addressess,addresses +addressings,addressing +addresss,address +addresssed,addressed +addressses,addresses +addresssing,addressing +addrress,address +addted,added addtion,addition addtional,additional +addtionally,additionally +addtitional,additional adealide,adelaide adecuate,adequate adeilade,adelaide @@ -523,32 +1108,79 @@ adequetely,adequately adequit,adequate adequitely,adequately adernaline,adrenaline +adge,edge,badge,adage +adges,edges,badges,adages adhearing,adhering adheisve,adhesive adherance,adherence adhevise,adhesive +adiacent,adjacent +adiditon,addition +adin,admin +adition,addition +aditional,additional +aditionally,additionally +aditionaly,additionally +aditionnal,additional +adivce,advice,advise adivser,adviser adivsor,advisor +adivsories,advisories +adivsoriy,advisory,advisories +adivsoriyes,advisories adivsors,advisors +adivsory,advisory +adjacentcy,adjacency,adjacence +adjacentsy,adjacency +adjactend,adjacent +adjancent,adjacent +adjascent,adjacent +adjasence,adjacence +adjasencies,adjacencies +adjasensy,adjacency +adjasent,adjacent +adjast,adjust +adjcence,adjacence +adjcencies,adjacencies +adjcent,adjacent +adjcentcy,adjacency adjectiveus,adjectives adjectivos,adjectives adjectivs,adjectives +adjsence,adjacence +adjsencies,adjacencies +adjsuted,adjusted +adjuscent,adjacent +adjusment,adjustment adjustabe,adjustable +adjustement,adjustment +adjustements,adjustments adjustible,adjustable +adjustificat,justification +adjustification,justification +adjustmant,adjustment +adjustmants,adjustments +adjustmenet,adjustment adknowledged,acknowledged adknowledges,acknowledges admendment,amendment +admi,admin adminastrator,administrator admininistrative,administrative +admininistrator,administrator +admininistrators,administrators +admininstrator,administrator administartion,administration administartor,administrator administartors,administrators +administation,administration administed,administered administerd,administered -administor,administer +administor,administer,administrator administored,administer administr,administer administraion,administration +administraively,administratively administrar,administrator administraron,administrator administrater,administrator @@ -574,11 +1206,13 @@ adminsitration,administration adminsitrative,administrative adminsitrator,administrator adminsitrators,administrators +adminssion,admission adminstered,administered adminstrate,administrate adminstration,administration adminstrative,administrative adminstrator,administrator +adminstrators,administrators admiraal,admiral admissability,admissibility admissable,admissible @@ -588,9 +1222,12 @@ admittadely,admittedly admittadly,admittedly admittetly,admittedly admittidly,admittedly +admn,admin +admnistrator,administrator admrial,admiral adn,and adnimistrator,administrators +adobted,adopted adolecent,adolescent adolence,adolescent adolencence,adolescence @@ -601,17 +1238,22 @@ adolescene,adolescence adolescense,adolescence adoloscent,adolescent adolsecent,adolescent +adoptor,adopter,adaptor +adoptors,adopters,adaptors adorbale,adorable adovcacy,advocacy adovcated,advocated adovcates,advocates +adpapted,adapted adpatation,adaptation adpater,adapter adpaters,adapters +adpter,adapter adquire,acquire adquired,acquired adquires,acquires adquiring,acquiring +adrea,area adreanline,adrenaline adrelanine,adrenaline adreneline,adrenaline @@ -621,12 +1263,26 @@ adresable,addressable adresing,addressing adress,address adressable,addressable +adresse,address adressed,addressed +adresses,addresses adressing,addressing +adresss,address +adressses,addresses adroable,adorable +adrress,address +adrresses,addresses aduiobook,audiobook adultey,adultery adultrey,adultery +adusted,adjusted +adustment,adjustment +advanatage,advantage +advanatages,advantages +advanatge,advantage +advandced,advanced +advane,advance +advaned,advanced advantadges,advantages advantageos,advantageous advantageus,advantageous @@ -634,9 +1290,11 @@ advantagious,advantageous advantagous,advantageous advantegeous,advantageous advanteges,advantages +advanved,advanced advatange,advantage advatanges,advantages adventageous,advantageous +adventages,advantages adventerous,adventures adventourus,adventurous adventrous,adventurous @@ -652,9 +1310,11 @@ adventurs,adventures adventuruous,adventurous adventurus,adventurous adventus,adventures +adverised,advertised adveristy,adversity adversiting,advertising adverst,adverts +advertice,advertise adverticed,advertised adverticement,advertisement advertis,adverts @@ -666,24 +1326,36 @@ advertisors,advertisers advertisted,advertised advertisters,advertisers advertisting,advertising +advertistment,advertisement +advertistments,advertisements advertisy,adversity advesary,adversary +advetise,advertise adviced,advised advirtisement,advertisement +adviseable,advisable adviseer,adviser adviseur,adviser +advisoriy,advisory,advisories +advisoriyes,advisories advisorys,advisors +advizable,advisable advocade,advocated advocats,advocates advocay,advocacy advsior,advisor advsiors,advisors +adwances,advances +aeactivate,deactivate,activate aeorspace,aerospace +aequidistant,equidistant +aequivalent,equivalent aeriel,aerial aeriels,aerials aeropsace,aerospace aerosapce,aerospace aersopace,aerospace +aesily,easily aestethic,aesthetic aestethically,aesthetically aestethics,aesthetics @@ -694,28 +1366,43 @@ aesthethics,aesthetics aestheticaly,aesthetically aestheticlly,aesthetically aesthitically,aesthetically +aesy,easy aethistic,atheistic aethists,atheists afair,affair +afaraid,afraid +afe,safe +afect,affect,effect +afecting,affecting +afer,after +afetr,after +affact,affect,effect affaires,affairs affaris,affairs affectionatley,affectionate affectionnate,affectionate +affekt,affect,effect affiars,affairs afficianados,aficionados afficionado,aficionado afficionados,aficionados affilate,affiliate +affilates,affiliates affiliato,affiliation affiliaton,affiliation affiliction,affiliation affilliate,affiliate +affinitied,affinities affinitiy,affinity +affinitized,affinities,affinity +affinitze,affinitize affintiy,affinity +affintize,affinitize affirmate,affirmative affirmitave,affirmative affirmitive,affirmative affirmitve,affirmative +affitnity,affinity affixiation,affiliation afflcition,affliction afflection,affliction @@ -725,8 +1412,10 @@ affliation,affliction affliciton,affliction afforadble,affordable affordible,affordable -affort,afford +affort,afford,effort affortable,affordable +afforts,affords +affraid,afraid affrimative,affirmative affulent,affluent afgahnistan,afghanistan @@ -735,12 +1424,15 @@ afghanastan,afghanistan afghanisthan,afghanistan afghansitan,afghanistan afhganistan,afghanistan +afinity,affinity afircan,african afircans,africans +afor,for aforememtioned,aforementioned aforementioend,aforementioned aforementiond,aforementioned aforementionned,aforementioned +aformentioned,aforementioned africain,african africanas,africans africaners,africans @@ -754,33 +1446,60 @@ afternon,afternoon afternooon,afternoon afterthougt,afterthought afterthougth,afterthought +afterw,after +aftrer,after +aftzer,after afwully,awfully againnst,against -agains,against +agains,against,again +againsg,against +againt,against againts,against agaisnt,against +agaist,against +agancies,agencies +agancy,agency +aganda,agenda,uganda aganist,against +agant,agent +agants,agents,against aggaravates,aggravates +aggegate,aggregate aggegrate,aggregate +aggessive,aggressive +aggessively,aggressively +agggregate,aggregate +aggragate,aggregate aggragating,aggravating +aggragator,aggregator aggravanti,aggravating aggraveted,aggravated +aggreagate,aggregate +aggreataon,aggregation +aggreate,aggregate +aggreation,aggregation aggreed,agreed aggreement,agreement +aggregatet,aggregated aggregatore,aggregate +aggregetor,aggregator +aggreggate,aggregate aggregious,egregious aggresions,aggression aggresive,aggressive +aggresively,aggressively aggressivley,aggressively aggressivly,aggressively aggressivo,aggression aggresssion,aggression +aggrevate,aggravate +aggrgate,aggregate aggrovated,aggravated aggrovating,aggravating agian,again agianst,against agin,again -agina,again +agina,again,angina aginst,against agircultural,agricultural agknowledged,acknowledged @@ -799,13 +1518,19 @@ agnostocism,agnosticism agnsoticism,agnosticism agonstic,agnostic agonsticism,agnosticism +agorithm,algorithm agracultural,agricultural +agrain,again agravate,aggravate agred,agreed agreeement,agreement +agreemnet,agreement +agreemnets,agreements agreemnt,agreement agregate,aggregate agregates,aggregates +agregation,aggregation +agregator,aggregator agreggate,aggregate agreing,agreeing agrentina,argentina @@ -813,10 +1538,15 @@ agressie,aggressive agression,aggression agressive,aggressive agressively,aggressively +agressiveness,aggressiveness +agressivity,aggressivity agressivley,aggressive agressivnes,aggressive agressor,aggressor +agresssive,aggressive agressvie,aggressive +agrgument,argument +agrguments,arguments agricolture,agriculture agriculteral,agricultural agriculteur,agriculture @@ -834,6 +1564,7 @@ agricuture,agriculture agrieved,aggrieved agrigultural,agricultural agrocultural,agricultural +agrresive,aggressive agruable,arguable agruably,arguably agruement,argument @@ -841,19 +1572,26 @@ agruing,arguing agrument,argument agrumentative,argumentative agruments,arguments +agument,argument +aguments,arguments agurement,argument +aheared,adhered ahev,have +ahlpa,alpha +ahlpas,alphas ahppen,happen ahtiest,atheist ahtletes,athletes ahtleticism,athleticism ahve,have aicraft,aircraft +aiffer,differ ailenated,alienated ailenating,alienating ailmony,alimony aincents,ancients aiport,airport +airator,aerator airboner,airborne airbore,airborne airbourne,airborne @@ -861,7 +1599,10 @@ airbrone,airborne aircaft,aircraft aircarft,aircraft aircrafts,aircraft +airfow,airflow +airial,aerial,arial airlfow,airflow +airloom,heirloom airosft,airsoft airplance,airplane airplans,airplanes @@ -873,11 +1614,55 @@ airscape,airspace airsfot,airsoft airzona,arizona aisian,asian +aixs,axis +aizmuth,azimuth +ajacence,adjacence +ajacencies,adjacencies +ajacency,adjacency +ajacent,adjacent +ajacentcy,adjacency +ajasence,adjacence +ajasencies,adjacencies +ajative,adjective +ajcencies,adjacencies ajdectives,adjectives +ajsencies,adjacencies +ajurnment,adjournment +ajust,adjust +ajusted,adjusted +ajustement,adjustment +ajusting,adjusting +ajustment,adjustment +ake,ache +akkumulate,accumulate +akkumulated,accumulated +akkumulates,accumulates +akkumulating,accumulating +akkumulation,accumulation +akkumulative,accumulative +akkumulator,accumulator akransas,arkansas +aks,ask +aksed,asked aksreddit,askreddit +akss,asks,ass +aktivate,activate +aktivated,activated +aktivates,activates +aktivating,activating +aktivation,activation +akumulate,accumulate +akumulated,accumulated +akumulates,accumulates +akumulating,accumulating +akumulation,accumulation +akumulative,accumulative +akumulator,accumulator +alaready,already albiet,albeit +albumns,albums alcehmist,alchemist +alcemy,alchemy alchemey,alchemy alchemsit,alchemist alchimest,alchemist @@ -894,57 +1679,324 @@ alcohal,alcohol alcohalics,alcoholics alcohalism,alcoholism alcoholc,alcoholics +alcoholical,alcoholic alcoholicas,alcoholics alcoholicos,alcoholics alcoholis,alcoholics alcoholisim,alcoholism alcoholsim,alcoholism aldutery,adultery +aleady,already +aleays,always alechmist,alchemist aledge,allege aledged,alleged aledges,alleges +alegance,allegiance alegbra,algebra alege,allege aleged,alleged alegience,allegiance +alegorical,allegorical aleinated,alienated aleinating,alienating aleniate,alienate +alers,alerts +aleviate,alleviate +aleviates,alleviates +aleviating,alleviating +alevt,alert +algebraical,algebraic +algebric,algebraic +algebrra,algebra +algee,algae algerba,algebra +alghorithm,algorithm +alghoritm,algorithm +alghoritmic,algorithmic +alghoritmically,algorithmically +alghoritms,algorithms +algined,alined +alginment,alignment +alginments,alignments +algohm,algorithm +algohmic,algorithmic +algohmically,algorithmically +algohms,algorithms +algoirthm,algorithm +algoirthmic,algorithmic +algoirthmically,algorithmically +algoirthms,algorithms +algoithm,algorithm +algoithmic,algorithmic +algoithmically,algorithmically +algoithms,algorithms +algolithm,algorithm +algolithmic,algorithmic +algolithmically,algorithmically +algolithms,algorithms +algoorithm,algorithm +algoorithmic,algorithmic +algoorithmically,algorithmically +algoorithms,algorithms +algoprithm,algorithm +algoprithmic,algorithmic +algoprithmically,algorithmically +algoprithms,algorithms +algorgithm,algorithm +algorgithmic,algorithmic +algorgithmically,algorithmically +algorgithms,algorithms +algorhithm,algorithm +algorhithmic,algorithmic +algorhithmically,algorithmically +algorhithms,algorithms +algorhitm,algorithm +algorhitmic,algorithmic +algorhitmically,algorithmically algorhitms,algorithms +algorhtm,algorithm +algorhtmic,algorithmic +algorhtmically,algorithmically +algorhtms,algorithms +algorhythm,algorithm +algorhythmic,algorithmic +algorhythmically,algorithmically +algorhythms,algorithms +algorhytm,algorithm +algorhytmic,algorithmic +algorhytmically,algorithmically +algorhytms,algorithms +algorightm,algorithm +algorightmic,algorithmic +algorightmically,algorithmically +algorightms,algorithms +algorihm,algorithm +algorihmic,algorithmic +algorihmically,algorithmically +algorihms,algorithms +algorihtm,algorithm +algorihtmic,algorithmic +algorihtmically,algorithmically +algorihtms,algorithms +algorith,algorithm algorithem,algorithm -algorithems,algorithm +algorithemic,algorithmic +algorithemically,algorithmically +algorithems,algorithm,algorithms +algorithic,algorithmic +algorithically,algorithmically algorithim,algorithm -algorithims,algorithm +algorithims,algorithm,algorithms algorithmes,algorithms +algorithmi,algorithm +algorithmical,algorithmically +algorithmm,algorithm +algorithmmic,algorithmic +algorithmmically,algorithmically +algorithmms,algorithms +algorithmn,algorithm +algorithmnic,algorithmic +algorithmnically,algorithmically algorithmns,algorithms algorithmus,algorithms algoriths,algorithms -algorithsm,algorithms +algorithsm,algorithms,algorithm +algorithsmic,algorithmic +algorithsmically,algorithmically +algorithsms,algorithms algorithum,algorithm algorithym,algorithm algorithyms,algorithm algoritm,algorithm algoritmes,algorithms +algoritmic,algorithmic +algoritmically,algorithmically algoritmos,algorithms algoritms,algorithms +algoroithm,algorithm +algoroithmic,algorithmic +algoroithmically,algorithmically +algoroithms,algorithms +algororithm,algorithm +algororithmic,algorithmic +algororithmically,algorithmically +algororithms,algorithms +algorothm,algorithm +algorothmic,algorithmic +algorothmically,algorithmically +algorothms,algorithms +algorrithm,algorithm +algorrithmic,algorithmic +algorrithmically,algorithmically +algorrithms,algorithms +algorritm,algorithm +algorritmic,algorithmic +algorritmically,algorithmically +algorritms,algorithms algorthim,algorithm +algorthimic,algorithmic +algorthimically,algorithmically algorthims,algorithms +algorthin,algorithm +algorthinic,algorithmic +algorthinically,algorithmically +algorthins,algorithms +algorthm,algorithm +algorthmic,algorithmic +algorthmically,algorithmically +algorthms,algorithms +algorthn,algorithm +algorthnic,algorithmic +algorthnically,algorithmically +algorthns,algorithms +algorthym,algorithm +algorthymic,algorithmic +algorthymically,algorithmically +algorthyms,algorithms +algorthyn,algorithm +algorthynic,algorithmic +algorthynically,algorithmically +algorthyns,algorithms algortihm,algorithm +algortihmic,algorithmic +algortihmically,algorithmically algortihms,algorithms +algortim,algorithm +algortimic,algorithmic +algortimically,algorithmically +algortims,algorithms +algortism,algorithm +algortismic,algorithmic +algortismically,algorithmically +algortisms,algorithms +algortithm,algorithm +algortithmic,algorithmic +algortithmically,algorithmically +algortithms,algorithms +algoruthm,algorithm +algoruthmic,algorithmic +algoruthmically,algorithmically +algoruthms,algorithms +algorwwithm,algorithm +algorwwithmic,algorithmic +algorwwithmically,algorithmically +algorwwithms,algorithms +algorythem,algorithm +algorythemic,algorithmic +algorythemically,algorithmically +algorythems,algorithms algorythims,algorithms +algorythm,algorithm +algorythmic,algorithmic +algorythmically,algorithmically algorythms,algorithms +algothitm,algorithm +algothitmic,algorithmic +algothitmically,algorithmically +algothitms,algorithms +algotighm,algorithm +algotighmic,algorithmic +algotighmically,algorithmically +algotighms,algorithms +algotihm,algorithm +algotihmic,algorithmic +algotihmically,algorithmically +algotihms,algorithms +algotirhm,algorithm +algotirhmic,algorithmic +algotirhmically,algorithmically +algotirhms,algorithms +algotithm,algorithm +algotithmic,algorithmic +algotithmically,algorithmically +algotithms,algorithms +algotrithm,algorithm +algotrithmic,algorithmic +algotrithmically,algorithmically +algotrithms,algorithms +alha,alpha +alhabet,alphabet +alhabetical,alphabetical +alhabetically,alphabetically +alhabeticaly,alphabetically +alhabets,alphabets +alhapet,alphabet +alhapetical,alphabetical +alhapetically,alphabetically +alhapeticaly,alphabetically +alhapets,alphabets +alhough,although +aliagn,align +aliasas,aliases +aliase,aliases,alias +aliasses,aliases alienet,alienate alientating,alienating alievating,alienating +alighed,aligned,alighted +alighned,aligned +alighnment,alignment +aligin,align +aligined,aligned +aligining,aligning +aliginment,alignment +aligins,aligns +aligment,alignment +aligments,alignments +alignation,alignment +alignd,aligned +aligne,align +alignement,alignment alignemnt,alignment +alignemnts,alignments +alignemt,alignment +alignes,aligns +alignmant,alignment +alignmen,alignment +alignmenet,alignment +alignmenets,alignments +alignmets,alignments +alignmment,alignment +alignmments,alignments +alignmnet,alignment +alignmnt,alignment +alignrigh,alignright +alikes,alike,likes alimoney,alimony alimunium,aluminium -alingment,alinement +aling,aline,along,ailing,sling +alinged,alined +alinging,alining +alingment,alinement,alinement +alings,alines,slings +alinment,alignment +alinments,alignments alirghty,alrighty +alising,aliasing +aliver,alive,liver,sliver allaince,alliance allainces,alliances +allcate,allocate +allcateing,allocating +allcater,allocator +allcaters,allocators +allcating,allocating +allcation,allocation +allcator,allocator +allcoate,allocate +allcoated,allocated +allcoateing,allocating +allcoateng,allocating +allcoater,allocator +allcoaters,allocators +allcoating,allocating +allcoation,allocation +allcoator,allocator +allcoators,allocators +allcommnads,allcommands +alle,all,alley +alled,called,allied alledge,allege alledged,alleged alledgedly,allegedly @@ -971,84 +2023,240 @@ allievate,alleviate alligeance,allegiance allign,align alligned,aligned +allignement,alignment +allignemnt,alignment +alligning,aligning +allignment,alignment +allignmenterror,alignmenterror +allignments,alignments +alligns,aligns allinace,alliance alliviate,alleviate +allk,all +alllocate,allocate +alllocation,allocation +alllow,allow +alllows,allows +allmost,almost +alloacate,allocate +alloate,allocate,allotted,allot +alloated,allocated,allotted +allocae,allocate +allocaed,allocated +allocaes,allocates +allocagtor,allocator +allocaiing,allocating +allocaing,allocating +allocaion,allocation +allocaions,allocations +allocaite,allocate +allocaites,allocates +allocaiting,allocating +allocaition,allocation +allocaitions,allocations +allocaiton,allocation +allocaitons,allocations +allocal,allocate +allocarion,allocation +allocat,allocate +allocatbale,allocatable +allocatedi,allocated +allocatedp,allocated +allocateing,allocating +allocateng,allocating +allocaton,allocation +allocatoor,allocator +allocatote,allocate +allocatrd,allocated +alloced,allocated +alloco,alloc +allocos,allocs +allocte,allocate +allocted,allocated +alloctions,allocations +alloctor,allocator +alloed,allowed,aloud +alloews,allows +allone,alone +allong,along +alloocates,allocates allopone,allophone allopones,allophones +allos,allows +alloted,allotted +alloud,aloud,allowed +allowd,allowed,allow,allows +allowe,allowed,allow,allows +allpication,application allready,already +allredy,already +allreight,alright +allright,alright +alls,all,falls +allso,also allthough,although -alltime +alltogeher,altogether +alltogehter,altogether alltogether,altogether +alltogetrher,altogether +alltogther,altogether +alltough,although +allways,always +allwo,allow +allwos,allows +allws,allows +allwys,always almightly,almighty almighy,almighty almigthy,almighty +almoast,almost +almostly,almost almsot,almost +alo,also +aloable,allowable,available +alocatable,allocatable +alocate,allocate +alocated,allocated +alocates,allocates +alocating,allocating +alocation,allocation alochol,alcohol alocholic,alcoholic alocholics,alcoholics alocholism,alcoholism +alog,along +alogirhtm,algorithm +alogirhtmic,algorithmic +alogirhtmically,algorithmically +alogirhtms,algorithms +alogirthm,algorithm +alogirthmic,algorithmic +alogirthmically,algorithmically +alogirthms,algorithms +alogned,aligned +alogorithms,algorithms alogrithm,algorithm +alogrithmic,algorithmic +alogrithmically,algorithmically alogrithms,algorithms alomst,almost +aloows,allows +alorithm,algorithm +alos,also alotted,allotted +alow,allow alowed,allowed alowing,allowing +alows,allows +alpabet,alphabet +alpabetic,alphabetic +alpabetical,alphabetical +alpabets,alphabets +alpah,alpha alpahbet,alphabet +alpahbetically,alphabetically +alph,alpha alphabeast,alphabet alphabeat,alphabet +alphabeticaly,alphabetically +alphabeticly,alphabetical alphabt,alphabet +alphapeticaly,alphabetically +alrady,already +alraedy,already +alread,already +alreadly,already +alreadt,already +alreasy,already +alreay,already alreayd,already +alreday,already +alredy,already +alreight,alright +alrelady,already alrightey,alrighty alrightly,alrighty alrightty,alrighty alrighy,alrighty alrigthy,alrighty alrington,arlington +alrms,alarms +alrogithm,algorithm alrorythm,algorithm -alse,else +alrteady,already +als,also +alse,else,also,false +alsmost,almost alsot,also +alsready,already altanta,atlanta altantic,atlantic alteast,atleast +altenative,alternative alteracion,alteration alterante,alternate alterantive,alternative alterantively,alternatively alterantives,alternatives alterarion,alteration +alterated,altered alterating,alteration +alterative,alternative +alteratives,alternatives alterato,alteration +alterior,ulterior alternador,alternator +alternaive,alternative +alternaives,alternatives alternar,alternator +alternarive,alternative +alternarives,alternatives alternater,alternator alternatevly,alternately alternatie,alternatives alternatiely,alternately alternatieve,alternative +alternatievly,alternatively alternativelly,alternatively alternativets,alternatives +alternativey,alternatively alternativley,alternatively alternativly,alternatively alternativos,alternatives alternatley,alternately alternatly,alternately alternatr,alternator -alternatve,alternate +alternatve,alternate,alternative alternatvely,alternately +alternetive,alternative +alternetives,alternatives alternetly,alternately alternitavely,alternatively alternitive,alternative alternitively,alternatively alternitives,alternatives +altetnative,alternative althetes,athletes althetic,athletic altheticism,athleticism althetics,athletics +althogh,although +althorithm,algorithm +althorithmic,algorithmic +althorithmically,algorithmically +althorithms,algorithms +althoug,although althought,although +althougth,although +althouth,although +altitide,altitude +altitute,altitude altnerately,alternately altogehter,altogether altogheter,altogether altough,although +altought,although +altready,already altriusm,altruism altriustic,altruistic altruisim,altruism @@ -1060,13 +2268,27 @@ altrusim,altruism altrusitic,altruistic alturism,altruism alturistic,altruistic +alue,value aluminim,aluminium aluminimum,aluminium alumnium,aluminium alunimum,aluminum -alusion,allusion +alusion,allusion,illusion +alvorithm,algorithm +alvorithmic,algorithmic +alvorithmically,algorithmically +alvorithms,algorithms +alwais,always +alwas,always +alwast,always alwasy,always +alwasys,always +alwauys,always +alway,always alwyas,always +alyways,always +amacing,amazing +amacingly,amazingly amalgomated,amalgamated amargeddon,armageddon amatersu,amateurs @@ -1075,22 +2297,36 @@ amateures,amateurs amateurest,amateurs amateus,amateurs amatuer,amateur -amature,armature +amature,armature,amateur +amazaing,amazing ambassabor,ambassador ambassader,ambassador ambassator,ambassador ambassedor,ambassador ambassidor,ambassador ambassodor,ambassador +ambedded,embedded +ambibuity,ambiguity +ambigious,ambiguous +ambigous,ambiguous +ambiguious,ambiguous ambiguitiy,ambiguity +ambiguos,ambiguous +ambitous,ambitious ambluance,ambulance +ambuguity,ambiguity ambuigity,ambiguity ambulancier,ambulance +ambulence,ambulance +ambulences,ambulances +amdgput,amdgpu +amendement,amendment amendmant,amendment amendmants,amendments amendmends,amendments amendmenters,amendments amendmet,amendments +amened,amended,amend amensia,amnesia amensty,amnesty amercia,america @@ -1113,30 +2349,52 @@ amerliorate,ameliorate amernian,armenian amethsyt,amethyst ameythst,amethyst +amgle,angle +amgles,angles amibguity,ambiguity +amiguous,ambiguous aminosity,animosity amke,make amking,making ammend,amend ammended,amended +ammending,amending ammendment,amendment ammendments,amendments +ammends,amends amministrative,administrative +ammong,among +ammongst,amongst +ammortizes,amortizes +ammoung,among +ammoungst,amongst ammount,amount ammused,amused amneisa,amnesia amnestry,amnesty amnsety,amnesty +amny,many amognst,amongst amohetamines,amphetamines +amongs,among amongts,amongst amonsgt,amongst +amonst,amongst +amonut,amount +amound,amount +amounds,amounts amoung,among amoungst,amongst +amout,amount +amoutn,amount +amoutns,amounts +amouts,amounts ampehtamine,amphetamine ampehtamines,amphetamines +amperstands,ampersands ampethamine,amphetamine ampethamines,amphetamines +amphasis,emphasis amphatamines,amphetamines amphedamines,amphetamines amphetamenes,amphetamines @@ -1149,8 +2407,11 @@ amphetimines,amphetamines amphetmaine,amphetamines amphetmaines,amphetamines ampilfy,amplify +amplifer,amplifier amplifiy,amplify amplifly,amplify +amplifyer,amplifier +ampty,empty amrageddon,armageddon amrchair,armchair amrenian,armenian @@ -1158,24 +2419,55 @@ amrpits,armpits amrstrong,armstrong amtheyst,amethyst amublance,ambulance +amuch,much amung,among amunition,ammunition +amunt,amount anachrist,anarchist analagous,analogous +analagus,analogous +analaog,analog analgoue,analogue +analgous,analogous +analig,analog +analise,analyse +analised,analysed +analiser,analyser +analises,analysis,analyses +analising,analysing +analisis,analysis analisys,analysis analitic,analytic analitical,analytical +analitically,analytically +analiticaly,analytically analitycal,analytical analitycs,analytics +analize,analyze +analized,analyzed +analizer,analyzer +analizes,analyzes +analizing,analyzing analoge,analogue analogeous,analogous +analogicaly,analogically +analoguous,analogous +analoguously,analogously +analogus,analogous analouge,analogue +analouges,analogues +analsyis,analysis analsyt,analyst analtyics,analytics -analyes,analyse +analye,analyse,analyze +analyed,analysed,analyzed +analyer,analyser,analyzer +analyers,analysers,analyzers +analyes,analyse,analyses,analyzes,analyze +analyis,analysis analyitcal,analytical analyitcs,analytics +analysator,analyser analyseas,analyses analysees,analyses analyseles,analyses @@ -1183,6 +2475,7 @@ analysens,analyses analyseras,analyses analyseres,analyses analysie,analyse +analysies,analyses,analysis analysise,analyses analysised,analyses analysises,analyses @@ -1191,12 +2484,20 @@ analysit,analyst analyste,analyse analystes,analysts analystics,analysts +analysus,analysis +analysy,analysis analysze,analyse +analyticall,analytical,analytically analyticals,analytics +analyticaly,analytically +analyticly,analytically analyts,analyst +analyzator,analyzer +analyzies,analysis,analyzes,analyzes analzye,analyze analzyed,analyzed analzying,analyzing +ananlog,analog anaolgue,analogue anarchim,anarchism anarchisim,anarchism @@ -1205,6 +2506,8 @@ anarchistm,anarchism anarchiszm,anarchism anarchsim,anarchism anarchsits,anarchists +anarquism,anarchism +anarquist,anarchist anaylse,analyse anaylses,analyses anaylsis,analysis @@ -1216,16 +2519,24 @@ anaylze,analyze anaylzed,analyzed anaylzing,analyzing anbd,and +ancapsulate,encapsulate ancedotal,anecdotal ancedotally,anecdotally ancedote,anecdote ancedotes,anecdotes anceint,ancient anceints,ancients +ancesetor,ancestor +ancesetors,ancestors +ancestore,ancestor +ancestores,ancestors ancestory,ancestry +anchord,anchored ancilliary,ancillary ancinets,ancients andd,and +andlers,handlers,antlers +andoid,android andoirds,androids andorid,android andorids,androids @@ -1235,9 +2546,12 @@ androgenous,androgynous androgeny,androgyny androiders,androids androides,androids +androidextra,androidextras androidos,androids androidtvs,androids +androind,android androis,androids +ane,and anecdatally,anecdotally anecdotale,anecdote anecdotallly,anecdotally @@ -1262,33 +2576,68 @@ aneroxic,anorexic anestheisa,anesthesia anesthetia,anesthesia anesthisia,anesthesia +anevironment,environment +anevironments,environments angirly,angrily angluar,angular angostic,agnostic angosticism,agnosticism angrilly,angrily angualr,angular +anhoter,another anicent,ancient anicents,ancients +anid,and anihilation,annihilation +animaing,animating +animaite,animate +animaiter,animator +animaiters,animators +animaiton,animation +animaitons,animations +animaitor,animator +animaitors,animators animatie,animate +animatior,animator,animation +animaton,animation +animatonic,animatronic animatte,animate +animore,anymore animostiy,animosity +aninate,animate +anination,animation aninteresting,uninteresting +aniother,another +anisotrophically,anisotropically +anitaliasing,antialiasing anitbiotic,antibiotic anitbiotics,antibiotics anitdepressant,antidepressants anitdepressants,antidepressants +anithing,anything +anitialising,antialiasing +anitime,anytime anitquated,antiquated anitque,antique +anitrez,antirez anitsocial,antisocial anitvirus,antivirus aniversary,anniversary +aniway,anyway +aniwhere,anywhere anixety,anxiety anlayses,analyses anlaytics,analytics +anlge,angle +anly,only +anlysis,analysis +anlyzing,analyzing anmesia,amnesia anmesty,amnesty +annay,annoy,any +annayed,annoyed +annaying,annoying +annays,annoys,any annhiliation,annihilation annihalated,annihilated annihalition,annihilation @@ -1308,20 +2657,32 @@ anniversery,anniversary anniversiary,anniversary anniversry,anniversary anniversy,anniversary +annoation,annotation annoint,anoint annointed,anointed annointing,anointing annoints,anoints +annoncement,announcement annonceurs,announcers +annonymous,anonymous annonymouse,anonymous +annotaion,annotation +annotaions,annotations +annoted,annotated +annother,another +annouce,announce annouced,announced +annoucement,announcement annoucenment,announcements +annouces,announces +annoucing,announcing annoucne,announce annoucnement,announcement annoucnements,announcements annoucners,announcers annoucnes,announces annoucning,announcing +annouing,annoying announceing,announcing announcemet,announcements announcemnet,announcements @@ -1329,6 +2690,11 @@ announcemnt,announcement announcemnts,announcements announcents,announces announched,announce +announcment,announcement +announcments,announcements +announed,announced +announement,announcement +announements,announcements annoyingy,annoyingly annoymous,anonymous annoymously,anonymously @@ -1341,6 +2707,8 @@ annyoingly,annoyingly anoerxia,anorexia anoerxic,anorexic anohter,another +anologon,analogon +anomally,anomaly anomisity,animosity anomolies,anomalies anomolous,anomalous @@ -1353,25 +2721,49 @@ anonimously,anonymously anonmyous,anonymous anonmyously,anonymously anonomously,anonymously +anononymous,anonymous +anonther,another anonymos,anonymous anonymosly,anonymously +anonymouse,anonymous anonymousny,anonymously anonymousy,anonymously anonymoys,anonymously +anonyms,anonymous +anonymus,anonymous anoreixa,anorexia anorexiac,anorexic anorexica,anorexia +anormal,abnormal +anormalies,anomalies +anormally,abnormally +anormaly,abnormally +anoter,another +anothe,another +anothers,another +anounce,announce anounced,announced anouncement,announcement +anount,amount anoxeria,anorexia anoxeric,anorexic +anoying,annoying +anoymous,anonymous anphetamines,amphetamines anrachist,anarchist +anroid,android ansalisation,nasalisation ansalization,nasalization ansestors,ancestors answerd,answered answeres,answers +answhare,answer +answhared,answered +answhareing,answering +answhares,answers +answharing,answering +answhars,answers +ansynchronous,asynchronous antaganist,antagonist antaganistic,antagonistic antagnoist,antagonist @@ -1381,18 +2773,27 @@ antagonisitic,antagonistic antagonistc,antagonistic antagonostic,antagonist antagonstic,antagonist +antaliasing,antialiasing antarcitca,antarctica antarctia,antarctica antarctida,antarctica antartic,antarctic +antecedant,antecedent +anteena,antenna +anteenas,antennas antennaes,antennas antennea,antenna antennna,antenna +anthing,anything +anthings,anythings +anthor,another anthromorphization,anthropomorphization anthropolgist,anthropologist anthropolgy,anthropology anthropoloy,anthropology anthropoly,anthropology +antialialised,antialiased +antialising,antialiasing antibiodic,antibiotic antibiodics,antibiotics antibioitcs,antibiotic @@ -1413,6 +2814,7 @@ anticipare,anticipate anticipatin,anticipation anticipato,anticipation anticipe,anticipate +anticpate,anticipate anticuated,antiquated antidepressents,antidepressants antidepresssants,antidepressants @@ -1435,39 +2837,92 @@ antogonistic,antagonistic antractica,antarctica antrhopology,anthropology antrophology,anthropology +antry,entry +antyhing,anything anual,annual +anually,annually anuglar,angular anulled,annulled +anumber,number +anway,anyway +anways,anyway +anwhere,anywhere +anwser,answer anwsered,answered anwsering,answering anwsers,answers anwyays,anyways anxeity,anxiety +anyawy,anyway +anyhing,anything anyhting,anything anyhwere,anywhere +anynmore,anymore anynomity,anonymity anynomous,anonymous anyoens,anyones anyoneis,anyones anyonse,anyones +anyother,another +anytghing,anything +anythig,anything anythign,anything +anythimng,anything +anytiem,anytime +anytihng,anything +anyting,anything +anytning,anything +anytrhing,anything +anytthing,anything anytying,anything +anywere,anywhere anywyas,anyways +aoache,apache +aond,and +aother,another,other,mother +aovid,avoid +apach,apache apacolypse,apocalypse apacolyptic,apocalyptic +apapted,adapted aparent,apparent +aparently,apparently aparment,apartment apartheied,apartheid aparthide,apartheid aparthied,apartheid apartmens,apartments apartmet,apartments +apdated,updated +apear,appear +apeared,appeared +apeends,appends +apend,append +apendage,appendage +apended,appended +apender,appender +apendices,appendices +apending,appending +apendix,appendix apenines,apennines +aperatures,apertures aperutre,aperture +apeture,aperture +apilogue,epilogue +aplha,alpha aplhabet,alphabet aplication,application +aplications,applications aplied,applied +aplitude,amplitude,aptitude +apllicatin,application +apllication,application apllications,applications +apllied,applied +apllies,applies +aplly,apply +apllying,applying +aplyed,applied apocalipse,apocalypse apocaliptic,apocalyptic apocalpyse,apocalypse @@ -1481,6 +2936,10 @@ apocalytic,apocalyptic apocalytpic,apocalyptic apocaplyse,apocalypse apocolapse,apocalypse +apointed,appointed +apointing,appointing +apointment,appointment +apoints,appoints apolagetic,apologetic apolagized,apologized apolagizing,apologizing @@ -1497,7 +2956,8 @@ apologistes,apologists apologistics,apologists apologitic,apologetic apologizeing,apologizing -apon,upon +apon,upon,apron +aportionable,apportionable aposltes,apostles apostels,apostles apostraphe,apostrophe @@ -1507,7 +2967,7 @@ apostrope,apostrophe apostropes,apostrophe apostrophie,apostrophe apostrophied,apostrophe -apostrophies,apostrophe +apostrophies,apostrophe,apostrophes appaluse,applause apparant,apparent apparantely,apparently @@ -1516,22 +2976,41 @@ appareal,apparel appareance,appearance appareances,appearances appareil,apparel +apparence,appearance apparenlty,apparently +apparenly,apparently apparentely,apparently apparenty,apparently +apparoches,approaches appart,apart appartment,apartment appartments,apartments -appealling,appealing +appealling,appealing,appalling appearane,appearances +appearantly,apparently appeard,appeared appeareance,appearance appearence,appearance appearences,appearances +appearently,apparently +appeares,appears appearnace,appearances +appearning,appearing +appeciate,appreciate +appeded,appended +appedn,append +appen,append +appendend,appended +appendent,appended +appendign,appending +appened,append,appended,happened +appeneded,appended appenines,apennines +appens,appends +appent,append apperance,appearance apperances,appearances +apperant,apparent,aberrant apperantly,apparently apperciate,appreciate apperciated,appreciated @@ -1540,41 +3019,104 @@ apperciation,appreciation apperead,appeared appereance,appearance appereances,appearances +appered,appeared +apperent,apparent +apperently,apparently +appers,appears +apperture,aperture appetitie,appetite appetities,appetite appetitite,appetite +appicability,applicability +appicable,applicable +appicaliton,application +appicant,applicant appication,application +appications,applications +appicative,applicative +appied,applied +appies,applies applainces,appliances applaudes,applause applaued,applaud +applay,apply +applcation,application +applcations,applications +appliable,applicable +applicabel,applicable applicabile,applicable +applicaion,application applicaiton,application applicaitons,applications +applicance,appliance applicaple,applicable +applicatable,applicable +applicaten,application applicates,applicants +applicatin,application applicatins,applicants +applicatio,application +applicationb,application +applicatios,applications +applicatiosn,applications applicato,application applicaton,application applicatons,applications applicible,applicable +appliction,application +applictions,applications appliences,appliances +applikation,application +appling,applying,appalling appluad,applaud appluase,applause +applyable,applicable +applycable,applicable +applyed,applied +applyes,applies +applyied,applied +applys,applies +applyting,applying +appned,append appointmet,appointments appoitnment,appointments appoitnments,appointments appologies,apologies appology,apology +appon,upon +appopriate,appropriate apporach,approach apporachable,approachable apporached,approached apporaches,approaches apporaching,approaching +apporiate,appropriate +apporoximate,approximate +apporoximated,approximated +apporpiate,appropriate apporpriate,appropriate apporpriately,appropriately apporpriation,appropriation apporximate,approximate apporximately,approximately +appove,approve +appoved,approved +appoximate,approximate +appoximately,approximately +appoximates,approximates +appoximation,approximation +appoximations,approximations +apppear,appear +apppears,appears +apppend,append +apppends,appends +appplet,applet +appplication,application +appplications,applications +appplying,applying +apppriate,appropriate +appproach,approach +apppropriate,appropriate appraoch,approach appraochable,approachable appraoched,approached @@ -1606,11 +3148,15 @@ appreicated,appreciated appreicates,appreciates appreicating,appreciating appreication,appreciation +apprended,appended,apprehended apprendice,apprentice apprentace,apprentice apprentie,apprentice apprentince,apprentice apprentise,apprentice +apprently,apparently +appreteate,appreciate +appreteated,appreciated appretiate,appreciate appretiation,appreciation appretince,apprentice @@ -1620,44 +3166,161 @@ appriciated,appreciated appriciates,appreciates appriecate,appreciates apprieciate,appreciate +appriopriate,appropriate +appripriate,appropriate +apprixamate,approximate +apprixamated,approximated +apprixamately,approximately +apprixamates,approximates +apprixamating,approximating +apprixamation,approximation +apprixamations,approximations +appriximate,approximate +appriximated,approximated +appriximately,approximately +appriximates,approximates +appriximating,approximating +appriximation,approximation +appriximations,approximations approachs,approaches approacing,approaching +approbiate,appropriate +approch,approach +approche,approach +approched,approached +approches,approaches +approching,approaching +approiate,appropriate +approopriate,appropriate +approoximate,approximate +approoximately,approximately +approoximates,approximates +approoximation,approximation +approoximations,approximations +approperiate,appropriate appropiate,appropriate +appropiately,appropriately appropirate,appropriate appropirately,appropriately appropiration,appropriation +approppriately,appropriately appropraite,appropriate appropraitely,appropriately approprate,appropriate +approprated,appropriated +approprately,appropriately +appropration,appropriation +approprations,appropriations appropreation,appropriation +appropriage,appropriate +appropriatedly,appropriately appropriatin,appropriation appropriatley,appropriately appropriatly,appropriately +appropriatness,appropriateness appropriato,appropriation appropriaton,appropriation approprietly,appropriately +appropritae,appropriate +approprite,appropriate +approproate,appropriate appropropiate,appropriate +appropropiately,appropriately +appropropreate,appropriate +appropropriate,appropriate approproximate,approximate +approproximately,approximately +approproximates,approximates +approproximation,approximation +approproximations,approximations +approprpiate,appropriate +approriate,appropriate +approriately,appropriately approrpiation,appropriation +approrpriate,appropriate +approrpriately,appropriately approstraphe,apostrophe +approuval,approval +approuve,approve +approuved,approved +approuves,approves +approuving,approving +approvement,approval approxamate,approximate approxamately,approximately +approxamates,approximates +approxamation,approximation +approxamations,approximations +approxamatly,approximately +approxametely,approximately approxiamte,approximate approxiamtely,approximately +approxiamtes,approximates +approxiamtion,approximation +approxiamtions,approximations +approxiate,approximate approxiately,approximately +approxiates,approximates +approxiation,approximation +approxiations,approximations approximatelly,approximately +approximatively,approximately approximatley,approximately approximatly,approximately +approximed,approximated +approximetely,approximately approximetly,approximately approximitely,approximately +approxmate,approximate +approxmately,approximately +approxmates,approximates +approxmation,approximation +approxmations,approximations approxmiate,approximate +approxmimation,approximation +apprpriate,appropriate +apprpriately,appropriately +appy,apply +appying,applying apratheid,apartheid +apreciate,appreciate +apreciated,appreciated +apreciates,appreciates +apreciating,appreciating +apreciation,appreciation +apreciative,appreciative aprehensive,apprehensive +apreteate,appreciate +apreteated,appreciated +apreteating,appreciating apreture,aperture +aproach,approach +aproached,approached +aproaches,approaches +aproaching,approaching +aproch,approach +aproched,approached +aproches,approaches +aproching,approaching +aproove,approve +aprooved,approved +apropiate,appropriate +apropiately,appropriately apropriate,appropriate +apropriately,appropriately aproval,approval aproximate,approximate aproximately,approximately +aproximates,approximates +aproximation,approximation +aproximations,approximations +aprrovement,approval +aprroximate,approximate +aprroximately,approximately +aprroximates,approximates +aprroximation,approximation +aprroximations,approximations +aprtment,apartment apsaragus,asparagus apsects,aspects apsergers,aspergers @@ -1667,51 +3330,136 @@ apsirin,aspirin apsotles,apostles apsotrophe,apostrophe aptitudine,aptitude +aqain,again aqaurium,aquarium aqcuaintance,acquaintance aqcuaintances,acquaintances aqcuainted,acquainted aqcuire,acquire aqcuired,acquired +aqcuires,acquires +aqcuiring,acquiring aqcuisition,acquisition aqquaintance,acquaintance aqquaintances,acquaintances aquaduct,aqueduct +aquaint,acquaint aquaintance,acquaintance aquainted,acquainted +aquainting,acquainting +aquaints,acquaints aquairum,aquarium aquarim,aquarium aquaruim,aquarium aquiantance,acquaintance aquire,acquire aquired,acquired +aquires,acquires aquiring,acquiring aquisition,acquisition +aquit,acquit aquitted,acquitted +aquries,acquires,equerries +arameters,parameters aramgeddon,armageddon aranged,arranged arangement,arrangement +araound,around +ararbic,arabic +aray,array +arays,arrays +arbiatraily,arbitrarily +arbiatray,arbitrary +arbibtarily,arbitrarily +arbibtary,arbitrary +arbibtrarily,arbitrarily +arbibtrary,arbitrary +arbiitrarily,arbitrarily +arbiitrary,arbitrary +arbirarily,arbitrarily +arbirary,arbitrary +arbiratily,arbitrarily +arbiraty,arbitrary +arbirtarily,arbitrarily arbirtary,arbitrary +arbirtrarily,arbitrarily +arbirtrary,arbitrary +arbitarary,arbitrary arbitarily,arbitrarily arbitary,arbitrary +arbitiarily,arbitrarily +arbitiary,arbitrary +arbitiraly,arbitrarily +arbitiray,arbitrary +arbitor,arbiter,arbitrator +arbitors,arbiters,arbitrators +arbitrailly,arbitrarily arbitraily,arbitrarily arbitraion,arbitration arbitrairly,arbitrarily -arbitrairy,arbitrarily +arbitrairy,arbitrarily,arbitrary +arbitral,arbitrary arbitralily,arbitrarily +arbitrally,arbitrarily +arbitralrily,arbitrarily +arbitralry,arbitrary +arbitraly,arbitrary arbitrarely,arbitrarily arbitrariliy,arbitrarily arbitrarilly,arbitrarily arbitrarion,arbitration -arbitrarly,arbitrary +arbitrariy,arbitrarily,arbitrary +arbitrarly,arbitrary,arbitrarily +arbitraryily,arbitrarily +arbitraryly,arbitrary arbitratily,arbitrarily +arbitratiojn,arbitration arbitraton,arbitration +arbitratrily,arbitrarily +arbitratrion,arbitration +arbitratry,arbitrary +arbitraty,arbitrary arbitray,arbitrary arbitre,arbiter +arbitrer,arbiter,arbitrator +arbitrers,arbiters,arbitrators +arbitriarily,arbitrarily +arbitriary,arbitrary +arbitrily,arbitrarily +arbitrion,arbitration +arbitriraly,arbitrarily +arbitriray,arbitrary +arbitrition,arbitration +arbitror,arbiter,arbitrator +arbitrors,arbiters,arbitrators +arbitrtily,arbitrarily +arbitrty,arbitrary +arbitry,arbitrary +arbitryarily,arbitrarily +arbitryary,arbitrary +arbitual,arbitrary +arbitually,arbitrarily +arbitualy,arbitrary +arbituarily,arbitrarily +arbituary,arbitrary +arbiturarily,arbitrarily +arbiturary,arbitrary arbiture,arbiter +arbort,abort +arborted,aborted +arborting,aborting +arborts,aborts arbritarily,arbitrarily arbritary,arbitrary arbritation,arbitration +arbritrarily,arbitrarily +arbritrary,arbitrary +arbtirarily,arbitrarily +arbtirary,arbitrary +arbtrarily,arbitrarily +arbtrary,arbitrary +arbutrarily,arbitrarily +arbutrary,arbitrary arcaheology,archeology arcahic,archaic arcehtype,archetype @@ -1720,11 +3468,11 @@ archaelogical,archaeological archaelogists,archaeologists archaelogy,archaeology archaeolgy,archaeology -archaoelogy,archaeology -archaology,archeology +archaoelogy,archaeology,archeology +archaology,archeology,archaeology archatypes,archetypes -archeaologist,archeologist -archeaologists,archeologists +archeaologist,archeologist,archeologist +archeaologists,archeologists,archeologists archeaology,archeology archetect,architect archetects,architects @@ -1739,10 +3487,19 @@ archetypus,archetypes archeytpes,archetypes archiac,archaic archictect,architect +archictecture,architecture +archictectures,architectures +archicture,architecture +archiecture,architecture +archiectures,architectures archimedian,archimedean +architct,architect +architcts,architects +architcture,architecture +architctures,architectures architechs,architects architecht,architect -architechts,architect +architechts,architect,architects architechturally,architecturally architechture,architecture architechtures,architectures @@ -1753,35 +3510,71 @@ architecte,architecture architectes,architects architectrual,architectural architectual,architectural +architectur,architecture architectureal,architectural architecturial,architectural +architecturs,architectures +architecturse,architectures architectuur,architecture architecure,architecture +architecures,architectures architecutral,architectural architecutre,architecture +architecutres,architectures +architecuture,architecture +architecutures,architectures architet,architect +architetcure,architecture +architetcures,architectures +architeture,architecture +architetures,architectures architexts,architects architexture,architecture +architure,architecture +architures,architectures architypes,archetypes +archiv,archive +archivel,archival +archor,anchor +archtecture,architecture +archtectures,architectures archtiects,architects +archtiecture,architecture +archtiectures,architectures +archtitecture,architecture +archtitectures,architectures archtype,archetype archtypes,archetypes +archvie,archive +archvies,archives +archving,archiving archytypes,archetypes arcitechture,architecture +arcitecture,architecture +arcitectures,architectures +arcticle,article arcylic,acrylic +ardiuno,arduino aready,already +areea,area aregument,argument aremnian,armenian areodynamics,aerodynamics areospace,aerospace aresnal,arsenal aretmis,artemis +argement,argument +argements,arguments +argemnt,argument +argemnts,arguments argentia,argentina argentinia,argentina argessive,aggressive argeument,argument argicultural,agricultural argiculture,agriculture +argment,argument +argments,arguments arguabley,arguably arguablly,arguably argubaly,arguably @@ -1789,15 +3582,38 @@ argubly,arguably arguements,arguments arguemet,arguement arguemnet,argument +arguemnt,argument arguemnts,arguments -arguemtn,arguement +arguemtn,arguement,argument +arguemtns,arguments +argumant,argument +argumants,arguments argumeent,argument +argumement,argument +argumements,arguments +argumemnt,argument +argumemnts,arguments +argumeng,argument +argumengs,arguments +argumens,arguments argumentas,arguments argumentate,argumentative argumentatie,argumentative +argumentents,arguments argumentitive,argumentative argumentos,arguments +argumeny,argument +argumet,argument +argumetn,argument +argumetns,arguments +argumets,arguments +argumnet,argument +argumnets,arguments +arhive,archive +arhives,archives arhtritis,arthritis +aribitary,arbitrary +aribiter,arbiter ariborne,airborne aribter,arbiter aribtrarily,arbitrarily @@ -1816,20 +3632,28 @@ aristote,aristotle aristotel,aristotle aritfact,artifact aritfacts,artifacts +arithemetic,arithmetic arithemtic,arithmetic +arithmatic,arithmetic arithmentic,arithmetic +arithmetc,arithmetic arithmethic,arithmetic arithmetisch,arithmetic arithmetric,arithmetic arithmitic,arithmetic aritmethic,arithmetic +aritmetic,arithmetic +aritrary,arbitrary +aritst,artist aritsts,artists arival,arrival +arive,arrive arizonia,arizona arkasnas,arkansas arlighty,alrighty arlignton,arlington arlingotn,arlington +arlready,already armagaddon,armageddon armageddan,armageddon armagedddon,armageddon @@ -1846,26 +3670,86 @@ armegaddon,armageddon armenain,armenian armenina,armenian armistace,armistice +armonic,harmonic armpitts,armpits armstorng,armstrong armstrog,armstrong arogant,arrogant arogent,arrogant +aronud,around aroud,around +aroung,around +arount,around arpanoid,paranoid arpatheid,apartheid arpeture,aperture +arquitecture,architecture +arquitectures,architectures +arraay,array +arragement,arrangement arragned,arranged +arraival,arrival +arral,array +arranable,arrangeable +arrance,arrange +arrane,arrange +arraned,arranged +arranement,arrangement +arranements,arrangements +arranent,arrangement +arranents,arrangements +arranes,arranges +arrang,arrange +arrangable,arrangeable +arrangaeble,arrangeable +arrangaelbe,arrangeable +arrangd,arranged +arrangde,arranged +arrangemenet,arrangement +arrangemenets,arrangements +arrangent,arrangement +arrangents,arrangements arrangerad,arranged +arrangmeent,arrangement +arrangmeents,arrangements +arrangmenet,arrangement +arrangmenets,arrangements arrangment,arrangement arrangments,arrangements +arrangnig,arranging +arrangs,arranges +arrangse,arranges +arrangt,arrangement +arrangte,arrange +arrangteable,arrangeable +arrangted,arranged +arrangtement,arrangement +arrangtements,arrangements +arrangtes,arranges +arrangting,arranging +arrangts,arrangements +arraning,arranging +arranment,arrangement +arranments,arrangements +arraows,arrows arrary,array +arrayes,arrays +arre,are +arreay,array arrengement,arrangement arrengements,arrangements arresst,arrests arrestes,arrests arrestos,arrests +arriveis,arrives +arrivial,arrival arround,around +arrray,array +arrrays,arrays +arrrives,arrives +arrtibute,attribute +arry,array,carry +arrys,arrays arsenaal,arsenal arsneal,arsenal artcile,article @@ -1874,7 +3758,12 @@ artemius,artemis arthimetic,arithmetic arthirtis,arthritis arthrits,arthritis +articaft,artifact +articafts,artifacts artical,article +articals,articles +articat,artifact +articats,artifacts artice,article articel,article articifial,artificial @@ -1906,6 +3795,7 @@ artistas,artists artistc,artistic artmeis,artemis artsits,artists +artuments,arguments arugable,arguable arugably,arguably arugement,argument @@ -1913,18 +3803,48 @@ aruging,arguing arugment,argument arugmentative,argumentative arugments,arguments +aruments,arguments arund,around +asai,asia +asain,asian asapragus,asparagus asbestoast,asbestos asbestoes,asbestos +asbolute,absolute +asbolutelly,absolutely +asbolutely,absolutely asborbed,absorbed asborbing,absorbing +asbtract,abstract +asbtracted,abstracted +asbtracter,abstracter +asbtracting,abstracting +asbtraction,abstraction +asbtractions,abstractions +asbtractly,abstractly +asbtractness,abstractness +asbtractor,abstractor +asbtracts,abstracts asburdity,absurdity asburdly,absurdly +asceding,ascending ascendend,ascended ascneded,ascended ascneding,ascending ascnesion,ascension +asend,ascend +asendance,ascendance +asendancey,ascendancy +asendancy,ascendancy +asended,ascended +asendence,ascendence +asendencey,ascendency +asendency,ascendency +asender,ascender +asending,ascending +asent,ascent +aserted,asserted +asertion,assertion asethetic,aesthetic asethetically,aesthetically asethetics,aesthetics @@ -1933,18 +3853,37 @@ aseuxal,asexual asexaul,asexual ashpalt,asphalt asign,assign +asigned,assigned +asignee,assignee +asignees,assignees +asigning,assigning +asignment,assignment +asignor,assignor +asigns,assigns +asii,ascii asiprin,aspirin +asisstant,assistant asisstants,assistants asissted,assisted asissts,assists +asistance,assistance +aske,ask +askes,asks askreddt,askreddit aslo,also +asnwer,answer asnwered,answered +asnwerer,answerer +asnwerers,answerers asnwering,answering asnwers,answers +asny,any +asnychronoue,asynchronous asociated,associated +asolute,absolute asorbed,absorbed aspahlt,asphalt +aspected,expected aspectos,aspects aspergerers,aspergers asperges,aspergers @@ -1978,27 +3917,73 @@ assassintation,assassination assassinted,assassinated assasssin,assassins assaultes,assaults +asscciated,associated +assciated,associated +asscii,ascii +asscociated,associated +asscoitaed,associated +assebly,assembly +assebmly,assembly assembe,assemble assembeld,assembled +assember,assembler assemblare,assemble assembleing,assembling assembley,assembly assemblie,assemble assemblying,assembling +assemblys,assemblies assemby,assembly +assemly,assembly +assemnly,assembly assemple,assemble assempling,assembling +assending,ascending +asser,assert +assersion,assertion assersions,assertions assertation,assertion assertin,assertions +assertio,assertion +assertting,asserting assesement,assessment +assesmenet,assessment +assesment,assessment +assessmant,assessment assestment,assessment +assgin,assign +assgined,assigned +assgining,assigning +assginment,assignment +assginments,assignments +assgins,assigns asshates,asshats asshatts,asshats asside,aside +assiged,assigned +assigend,assigned +assiging,assigning +assigment,assignment +assigments,assignments +assigmnent,assignment +assignalble,assignable +assigne,assign,assigned +assignement,assignment +assignements,assignments assignemnt,assignment assignemnts,assignments +assignemtn,assignment +assignend,assigned +assignenmet,assignment +assignes,assigns +assignmenet,assignment +assignmens,assignments +assignmet,assignment +assignmnet,assignment +assignt,assign +assigntment,assignment assimalate,assimilate +assime,assume assimialted,assimilate assimilant,assimilate assimilare,assimilate @@ -2009,8 +3994,26 @@ assimiliate,assimilate assimliate,assimilate assimliated,assimilate assimulate,assimilate +assined,assigned +assing,assign +assinged,assigned +assinging,assigning +assingled,assigned assingment,assignment assingments,assignments +assingned,assigned +assings,assigns +assinment,assignment +assiocate,associate +assiocated,associated +assiocates,associates +assiocating,associating +assiocation,association +assiociate,associate +assiociated,associated +assiociates,associates +assiociating,associating +assiociation,association assisnate,assassinate assissinated,assassinated assisst,assists @@ -2022,21 +4025,36 @@ assistantes,assistants assistat,assistants assistence,assistance assistendo,assisted +assistent,assistant assistents,assistants assistsnt,assistants assit,assist assitant,assistant +assition,assertion +assmbler,assembler assmeble,assemble assmebled,assembled assmebling,assembling assmebly,assembly +assmelber,assembler +assmption,assumption +assmptions,assumptions assnage,assange assocaited,associated assocaites,associates assocaition,associations +assocate,associate +assocated,associated +assocates,associates +assocating,associating assocation,association +assocations,associations +assocciative,associative associaiton,associations +associatated,associated +associatd,associated associatie,associated +associatied,associated associaties,associates associatin,associations associationg,associating @@ -2044,37 +4062,118 @@ associationthis,associations associato,association associaton,association associatons,associations +associcate,associate +associcated,associated +associcates,associates +associcating,associating +associdated,associated +associeted,associated associsted,associates +assocition,association +associuated,associated +assoction,association +assoiated,associated assoicate,associate assoicated,associated assoicates,associates assoication,association assoications,associations +assoiciative,associative +assomption,assumption +assosciate,associate +assosciated,associated +assosciates,associates +assosciating,associating +assosiacition,association +assosiacitions,associations +assosiacted,associated +assosiate,associate assosiated,associated assosiates,associates assosiating,associating assosiation,association assosiations,associations assosication,assassination +assotiated,associated assotiations,associations assoziation,association asssasin,assassin asssasins,assassins asssassans,assassins +asssembler,assembler +asssembly,assembly +asssert,assert +asssertion,assertion asssits,assists +asssociated,associated +asssume,assume +asssumes,assumes +asssuming,assuming assualt,assault assualted,assaulted assualts,assaults +assue,assume,assure +assuembly,assembly assulated,assaulted +assum,assume +assuma,assume +assumad,assumed +assumang,assuming +assumas,assumes +assumbe,assume +assumbed,assumed +assumbes,assumes +assumbing,assuming +assumend,assumed +assumking,assuming +assumme,assume +assummed,assumed +assummes,assumes +assumming,assuming +assumne,assume +assumned,assumed +assumnes,assumes +assumning,assuming +assumong,assuming +assumotion,assumption +assumotions,assumptions +assumpation,assumption assumptious,assumptions +assums,assumes +assumse,assumes +assumtion,assumption +assumtions,assumptions +assumtpion,assumption +assumtpions,assumptions +assumu,assume +assumud,assumed +assumue,assume +assumued,assumed +assumues,assumes +assumuing,assuming +assumung,assuming +assumuption,assumption +assumuptions,assumptions +assumus,assumes +assupmption,assumption assupmtion,assumptions +assuption,assumption +assuptions,assumptions +assurred,assured assymetric,asymmetric assymetrical,asymmetrical +assymetries,asymmetries +assymetry,asymmetry +assymmetric,asymmetric +assymmetrical,asymmetrical +assymmetries,asymmetries +assymmetry,asymmetry asteorid,asteroid asteorids,asteroids +asterices,asterisks astericks,asterisk asterik,asterisk -asteriks,asterisk +asteriks,asterisk,asterisks asteriod,asteroid asteriods,asteroids asteroides,asteroids @@ -2083,6 +4182,9 @@ astersik,asterisk asthetic,aesthetic asthetical,aesthetical asthetically,aesthetically +asthetics,aesthetics +astiimate,estimate +astiimation,estimation astonashing,astonishing astonising,astonishing astonoshing,astonishing @@ -2107,20 +4209,70 @@ astronuat,astronaut astronuats,astronauts astrounat,astronaut asume,assume +asumed,assumed +asumes,assumes +asuming,assuming +asumption,assumption +asure,assure asuterity,austerity asutralian,australian asutria,austria asutrian,austrian +asychronize,asynchronize +asychronized,asynchronized asychronous,asynchronous +asychronously,asynchronously +asycn,async +asycronous,asynchronous +asymetic,asymmetric +asymetri,asymmetric,asymmetry +asymetric,asymmetric +asymetrical,asymmetrical +asymetricaly,asymmetrically +asymmeric,asymmetric +asymmetri,asymmetric,asymmetry +asynchnous,asynchronous +asynchonous,asynchronous +asynchonously,asynchronously +asynchornous,asynchronous +asynchoronous,asynchronous +asynchrnous,asynchronous +asynchrnously,asynchronously +asynchromous,asynchronous +asynchron,asynchronous +asynchroneously,asynchronously +asynchronious,asynchronous +asynchronlous,asynchronous +asynchrons,asynchronous +asynchroous,asynchronous +asynchrounous,asynchronous +asynchrounsly,asynchronously asyncronous,asynchronous +asyncronously,asynchronously +asynnc,async +asynschron,asynchronous +atach,attach +atached,attached +ataching,attaching +atachment,attachment +atachments,attachments +atack,attack atain,attain atatchment,attachment atatchments,attachments atcualy,actually atelast,atleast +atempt,attempt atempting,attempting +atempts,attempts +atendance,attendance +atended,attended +atendee,attendee +atends,attends +atention,attention atheisim,atheism atheistc,atheistic +atheistical,atheistic atheistisch,atheistic atheltes,athletes atheltic,athletic @@ -2128,6 +4280,7 @@ athelticism,athleticism atheltics,athletics athenean,athenian atheneans,athenians +ather,other athesim,atheism athesitic,atheistic athesits,atheists @@ -2149,11 +4302,17 @@ athletisicm,athleticism athletisim,athleticism athletisism,athleticism athlets,athletes +athough,although +athron,athlon +athros,atheros atittude,attitude atlantc,atlantic atlantia,atlanta atleats,atleast atlesat,atleast +atll,all +atmoic,atomic +atmoically,atomically atmoizer,atomizer atmopshere,atmosphere atmopsheric,atmospheric @@ -2162,11 +4321,19 @@ atmoshperic,atmospheric atmosoheric,atmospheric atmosphereic,atmospheric atmosphir,atmospheric +atomatically,automatically +atomical,atomic +atomicly,atomically +atomiticity,atomicity atomsphere,atmosphere atomspheric,atmospheric atomzier,atomizer +atorecovery,autorecovery atorney,attorney +atquired,acquired atremis,artemis +atribs,attribs +atribut,attribute atribute,attribute atributed,attributed atributes,attributes @@ -2178,38 +4345,86 @@ atrittion,attrition atrocitites,atrocities atrocoties,atrocities atrosities,atrocities +atrribute,attribute +atrributes,attributes +atrtribute,attribute +atrtributes,attributes +attaced,attached +attachd,attached +attachement,attachment +attachements,attachments attachemnt,attachment attachemnts,attachments +attachen,attach +attachged,attached +attachmant,attachment +attachmants,attachments attachmet,attachments +attachs,attaches +attachted,attached attackeras,attackers attackerasu,attackers attackerats,attackers attackes,attackers +attacs,attacks +attacthed,attached attactment,attachment attactments,attachments -attaindre,attainder +attaindre,attainder,attained +attampt,attempt +attatch,attach +attatched,attached +attatches,attaches +attatching,attaching +attatchment,attachment +attatchments,attachments +attch,attach +attched,attached +attches,attaches +attching,attaching +attchment,attachment attemp,attempt attemped,attempted +attemping,attempting +attemppt,attempt attemps,attempts +attemptting,attempting attemt,attempt attemted,attempted attemting,attempting +attemtp,attempt attemtped,attempted attemtping,attempting attemtps,attempts +attemtpted,attempted +attemtpts,attempts attemts,attempts attendence,attendance attendent,attendant attendents,attendants attened,attended +attennuation,attenuation attension,attention +attented,attended +attepmpt,attempt +attept,attempt +attetntion,attention +attibute,attribute +attibuted,attributed +attibutes,attributes attidute,attitude attirbute,attribute attirbutes,attributes +attiribute,attribute attirtion,attrition attitide,attitude +attmept,attempt attmepted,attempted attmepting,attempting +attmpt,attempt +attnetion,attention +attosencond,attosecond +attosenconds,attoseconds attracs,attracts attracters,attracts attractes,attracts @@ -2219,15 +4434,69 @@ attractifs,attracts attractin,attraction attraktion,attraction attraktive,attractive +attrbiute,attribute +attribbute,attribute +attribiute,attribute +attribiutes,attributes +attribte,attribute +attribted,attributed +attribtes,attributes,attribute +attribting,attributing +attribtue,attribute +attribtutes,attributes +attribude,attribute attribue,attribute +attribues,attributes +attribuite,attribute +attribuites,attributes +attribuition,attribution attribuito,attribution +attribure,attribute +attribured,attributed +attribures,attributes +attriburte,attribute +attriburted,attributed +attriburtes,attributes +attriburtion,attribution +attribut,attribute +attributei,attribute +attributen,attribute attributo,attribution attributred,attributed attributs,attributes attributted,attribute +attribye,attribute +attribyes,attributes +attribyte,attribute +attribytes,attributes +attriebute,attribute +attriebuted,attributed +attriebutes,attributes +attriebuting,attributing attritube,attribute attritubes,attributes +attriubtes,attributes +attriubute,attribute attrocities,atrocities +attrribute,attribute +attrubite,attribute +attrubites,attributes +attrubte,attribute +attrubtes,attributes +attrubure,attribute +attrubures,attributes +attrubute,attribute +attrubutes,attributes +attrubyte,attribute +attrubytes,attributes +attruibute,attribute +attruibutes,attributes +atttached,attached +atttribute,attribute +atttributes,attributes +atuhentication,authentication +auccess,success +auccessive,successive aucitons,auctions auctioners,auctions auctionrs,auctions @@ -2235,6 +4504,7 @@ audactiy,audacity audbile,audible audcaity,audacity audeince,audience +audiance,audience audibel,audible audiobok,audiobook audiobookas,audiobooks @@ -2243,12 +4513,24 @@ audioboook,audiobook audioboooks,audiobook audioboost,audiobooks audomoderator,automoderator +auguest,august +augument,argument,augment auhtenticate,authenticate +auhtor,author +auhtors,authors auidobook,audiobook auidobooks,audiobooks +aunthenticate,authenticate +aunthenticated,authenticated +aunthenticates,authenticates +aunthenticating,authenticating +auospacing,autospacing +auot,auto auotattack,autoattack auotcorrect,autocorrect +auotmatic,automatic auromated,automated +aussian,gaussian,russian,austrian austeriy,austerity austira,austria austiran,austrian @@ -2273,23 +4555,180 @@ australina,australians australlian,australian austrija,austria austrila,austria -austrlaian,australians +austrlaian,australians,australian +autasave,autosave +autasaves,autosaves +autenticate,authenticate +autenticated,authenticated +autenticates,authenticates +autenticating,authenticating +autentication,authentication +authecate,authenticate +authecated,authenticated +authecates,authenticates +authecating,authenticating +authecation,authentication +authecator,authenticator +authecators,authenticators +authenaticate,authenticate +authenaticated,authenticated +authenaticates,authenticates +authenaticating,authenticating +authenatication,authentication +authenaticator,authenticator +authenaticators,authenticators +authencate,authenticate +authencated,authenticated +authencates,authenticates +authencating,authenticating +authencation,authentication +authencator,authenticator +authencators,authenticators +authenciate,authenticate +authenciated,authenticated +authenciates,authenticates +authenciating,authenticating +authenciation,authentication +authenciator,authenticator +authenciators,authenticators +authencicate,authenticate +authencicated,authenticated +authencicates,authenticates +authencicating,authenticating +authencication,authentication +authencicator,authenticator +authencicators,authenticators +authencity,authenticity +authencticate,authenticate +authencticated,authenticated +authencticates,authenticates +authencticating,authenticating +authenctication,authentication +authencticator,authenticator +authencticators,authenticators +authendicate,authenticate +authendicated,authenticated +authendicates,authenticates +authendicating,authenticating +authendication,authentication +authendicator,authenticator +authendicators,authenticators +authenenticate,authenticate +authenenticated,authenticated +authenenticates,authenticates +authenenticating,authenticating +authenentication,authentication +authenenticator,authenticator +authenenticators,authenticators +authenfie,authenticate +authenfied,authenticated +authenfies,authenticates +authenfiing,authenticating +authenfiion,authentication +authenfior,authenticator +authenfiors,authenticators +authenicae,authenticate +authenicaed,authenticated +authenicaes,authenticates +authenicaing,authenticating +authenicaion,authentication +authenicaor,authenticator +authenicaors,authenticators +authenicate,authenticate +authenicated,authenticated +authenicates,authenticates +authenicating,authenticating +authenication,authentication +authenicator,authenticator +authenicators,authenticators +authenificate,authenticate +authenificated,authenticated +authenificates,authenticates +authenificating,authenticating +authenification,authentication +authenificator,authenticator +authenificators,authenticators +authenitcate,authenticate +authenitcated,authenticated +authenitcates,authenticates +authenitcating,authenticating authenitcation,authentication +authenitcator,authenticator +authenitcators,authenticators +autheniticate,authenticate +autheniticated,authenticated +autheniticates,authenticates +autheniticating,authenticating +authenitication,authentication +autheniticator,authenticator +autheniticators,authenticators +authenricate,authenticate +authenricated,authenticated +authenricates,authenticates +authenricating,authenticating +authenrication,authentication +authenricator,authenticator +authenricators,authenticators +authentcated,authenticated authenticaion,authentication authenticaiton,authentication +authenticateion,authentication authenticaton,authentication authenticiy,authenticity authenticor,authenticator +authentiction,authentication authenticty,authenticity authenticy,authenticity +authentification,authentication authentisity,authenticity auther,author +autherisation,authorisation +autherise,authorise autherization,authorization +autherize,authorize autherized,authorized +authers,authors +authethenticate,authenticate +authethenticated,authenticated +authethenticates,authenticates +authethenticating,authenticating +authethentication,authentication +authethenticator,authenticator +authethenticators,authenticators +authethicate,authenticate +authethicated,authenticated +authethicates,authenticates +authethicating,authenticating +authethication,authentication +authethicator,authenticator +authethicators,authenticators +autheticate,authenticate +autheticated,authenticated +autheticates,authenticates +autheticating,authenticating +authetication,authentication +autheticator,authenticator +autheticators,authenticators +authetnicate,authenticate +authetnicated,authenticated +authetnicates,authenticates +authetnicating,authenticating +authetnication,authentication +authetnicator,authenticator +authetnicators,authenticators +authetnticate,authenticate +authetnticated,authenticated +authetnticates,authenticates +authetnticating,authenticating +authetntication,authentication +authetnticator,authenticator +authetnticators,authenticators authobiographic,autobiographic authobiography,autobiography +authoer,author authoratitive,authoritative authorative,authoritative +authorded,authored authoritate,authoritative authoritatian,authoritarian authoritation,authorization @@ -2299,22 +4738,40 @@ authorithies,authorities authorithy,authority authoritiers,authorities authorititive,authoritative +authoritive,authoritative authoritorian,authoritarian authorizaton,authorization +authorizeed,authorized authorotative,authoritative authoroties,authorities +authos,authors,autos authroity,authority authroization,authorization authroized,authorized +authror,author +authrored,authored +authrorisation,authorisation authrorities,authorities +authrorization,authorization +authrors,authors +autimatic,automatic +autimatically,automatically autisitc,autistic autistc,autistic autistisch,autistic +autmatically,automatically autoattak,autoattack autoattaks,autoattack autoattk,autoattack autoatttack,autoattack autochtonous,autochthonous +autocommiting,autocommitting +autoconplete,autocomplete +autoconpleted,autocompleted +autoconpletes,autocompletes +autoconpleting,autocompleting +autoconpletion,autocompletion +autocoomit,autocommit autocorect,autocorrect autocoreect,autocorrect autocorrct,autocorrect @@ -2324,11 +4781,36 @@ autocorret,autocorrect autocorrext,autocorrect autocorrrect,autocorrect autoctonous,autochthonous +autoeselect,autoselect +autofilt,autofilter +autofomat,autoformat +autoformating,autoformatting +autogenrated,autogenerated +autogenratet,autogenerated +autogenration,autogeneration autograh,autograph autograpgh,autograph +autogroping,autogrouping autogrpah,autograph +autohorized,authorized +autoincrememnt,autoincrement +autoincrementive,autoincrement autokorrect,autocorrect +automaatically,automatically +automagicaly,automagically +automaitc,automatic +automaitcally,automatically +automanifactured,automanufactured +automatcally,automatically +automatially,automatically +automatical,automatically,automatic,automated +automaticall,automatically,automatic +automaticallly,automatically +automaticaly,automatically +automaticalyl,automatically +automaticalyy,automatically automatice,automate +automaticlly,automatically automaticly,automatically automatico,automation automatied,automate @@ -2337,6 +4819,8 @@ automato,automation automatonic,automation automatron,automation automatted,automate +autometic,automatic +autometically,automatically automibile,automobile automitive,automotive automobilies,automobile @@ -2355,61 +4839,234 @@ automotice,automotive automotion,automation automotize,automotive automotove,automotive +automtically,automatically +autonagotiation,autonegotiation autonamous,autonomous autonation,automation +autonegatiotiation,autonegotiation +autonegatiotiations,autonegotiations +autonegoatiation,autonegotiation +autonegoatiations,autonegotiations +autonegoation,autonegotiation +autonegoations,autonegotiations +autonegociated,autonegotiated +autonegociation,autonegotiation +autonegociations,autonegotiations +autonegogtiation,autonegotiation +autonegogtiations,autonegotiations +autonegoitation,autonegotiation +autonegoitations,autonegotiations +autonegoptionsotiation,autonegotiation +autonegoptionsotiations,autonegotiations +autonegosiation,autonegotiation +autonegosiations,autonegotiations +autonegotaiation,autonegotiation +autonegotaiations,autonegotiations +autonegotaition,autonegotiation +autonegotaitions,autonegotiations +autonegotatiation,autonegotiation +autonegotatiations,autonegotiations +autonegotation,autonegotiation +autonegotations,autonegotiations +autonegothiation,autonegotiation +autonegothiations,autonegotiations +autonegotication,autonegotiation +autonegotications,autonegotiations +autonegotioation,autonegotiation +autonegotioations,autonegotiations +autonegotion,autonegotiation +autonegotionation,autonegotiation +autonegotionations,autonegotiations +autonegotions,autonegotiations +autonegotiotation,autonegotiation +autonegotiotations,autonegotiations +autonegotitaion,autonegotiation +autonegotitaions,autonegotiations +autonegotitation,autonegotiation +autonegotitations,autonegotiations +autonegotition,autonegotiation +autonegotitions,autonegotiations +autonegoziation,autonegotiation +autonegoziations,autonegotiations +autoneogotiation,autonegotiation +autoneotiation,autonegotiation autonimous,autonomous +autonogotiation,autonegotiation autonomity,autonomy autonomos,autonomous autononous,autonomous +autonymous,autonomous +autopsec,autospec autor,author +autorealease,autorelease +autorisation,authorisation +autoritative,authoritative autoritharian,authoritarian autority,authority +autorization,authorization +autoropeat,autorepeat +autors,authors +autosae,autosave +autosavegs,autosaves +autosaveperodical,autosaveperiodical +autosence,autosense autsitic,autistic auttoatack,autoattack +autum,autumn +auxialiary,auxiliary +auxilaries,auxiliaries auxilary,auxiliary +auxileries,auxiliaries +auxilery,auxiliary +auxiliar,auxiliary auxillaries,auxiliaries auxillary,auxiliary +auxilleries,auxiliaries +auxillery,auxiliary auxilliaries,auxiliaries auxilliary,auxiliary +auxiluary,auxiliary +auxliliary,auxiliary avacodos,avocados avaiable,available +avaialable,available +avaialbale,available +avaialbe,available +avaialbel,available +avaialbility,availability avaialble,available +avaiblable,available +avaible,available +avaiiability,availability +avaiiable,available +avaiibility,availability +avaiible,available +avaiilable,available +availaable,available +availabable,available +availabal,available availabale,available +availabality,availability +availabble,available availabe,available +availabed,available +availabel,available +availabele,available +availabelity,availability availabiliy,availability availabillity,availability availabilty,availability +availabke,available +availabl,available +availabled,available +availablen,available availablity,availability +availabyl,available +availaiable,available availaible,available +availailability,availability +availaility,availability +availalable,available +availalbe,available +availalble,available +availale,available +availaliable,available +availality,availability +availanle,available +availavble,available +availavility,availability +availavle,available +availbale,available +availbe,available availble,available +availeable,available +availeble,available availiable,available +availibility,availability +availibilty,availability availible,available +availlable,available avaition,aviation avalable,available avalaible,available avalance,avalanche avaliability,availability avaliable,available +avalibale,available +avalible,available +avaloable,available +avaluate,evaluate +avaluated,evaluated +avaluates,evaluates +avaluating,evaluating +avance,advance +avanced,advanced +avances,advances +avancing,advancing +avaoid,avoid +avaoidable,avoidable +avaoided,avoided +avarage,average +avarageing,averaging +avarege,average +avary,every,aviary avataras,avatars avatards,avatars avatares,avatars avation,aviation +avcoid,avoid +avcoids,avoids +avdisories,advisories +avdisoriy,advisory,advisories +avdisoriyes,advisories +avdisory,advisory +avengence,vengeance averadge,averaged averageadi,averaged averageed,averaged averageifs,averages +averagine,averaging avergaed,averaged avergaes,averages +averload,overload +averloaded,overloaded +averloads,overloads +avertising,advertising +avgerage,average +aviable,available aviaiton,aviation avialability,availability avialable,available +avilability,availability avilable,available +aviod,avoid +avioded,avoided +avioding,avoiding +aviods,avoids +avisories,advisories +avisoriy,advisory,advisories +avisoriyes,advisories +avisory,advisory avnegers,avengers +avod,avoid avodacos,avocados +avoded,avoided +avoding,avoiding +avods,avoids +avoidence,avoidance +avoinding,avoiding +avriable,variable +avriables,variables +avriant,variant +avriants,variants avtaars,avatars +avtive,active awakend,awakened awakenend,awakened awared,awarded +aways,always,away +aweful,awful +awefully,awfully awekened,weakened awesomeley,awesomely awesomelly,awesomely @@ -2426,9 +5083,23 @@ awknowledging,acknowledging awkwardess,awkwardness awkwardsness,awkwardness awkwardy,awkwardly +awming,awning +awmings,awnings +awnser,answer awnsered,answered awnsering,answering +awnsers,answers +awoid,avoid +awsome,awesome awya,away +axises,axes +axix,axis +axpressed,expressed +aysnc,async +ayway,anyway,away +ayways,always +ba,by,be +bable,babel,table,bible bablyon,babylon babysister,babysitter babysite,babysitter @@ -2436,52 +5107,112 @@ babysiting,babysitting babysittng,babysitting babysittter,babysitter babysittting,babysitting +bacause,because baceause,because bacehlor,bachelor bacehlors,bachelors +bacground,background bachelores,bachelors bachelour,bachelor bachleor,bachelor bachleors,bachelors bacholer,bachelor bacholers,bachelors +bacic,basic +backards,backwards backbacking,backpacking +backbround,background +backbrounds,backgrounds backdooor,backdoor backdor,backdoor backeast,backseat +backedn,backend +backedns,backends +backened,backend,blackened +backeneds,backends,blackens backerds,backers backfeild,backfield backfied,backfield backfiled,backfield backgorund,background backgorunds,backgrounds +backgound,background +backgounds,backgrounds +backgournd,background +backgournds,backgrounds +backgrond,background +backgronds,backgrounds backgroud,background backgroudn,backgrounds backgrouds,backgrounds +backgroung,background +backgroungs,backgrounds backgrouns,backgrounds +backgrount,background +backgrounts,backgrounds +backgrund,background +backgrunds,backgrounds backgruond,backgrounds backhacking,backpacking backjacking,backpacking +backlght,backlight +backlghting,backlighting +backlghts,backlights +backned,backend +backneds,backends +backound,background +backounds,backgrounds backpacing,backpacking backpackng,backpacking backpacs,backpacks backpakcs,backpacks +backpsace,backspace +backrefence,backreference backrgound,backgrounds +backround,background backrounds,backgrounds +backsapce,backspace +backslase,backslash +backslases,backslashes +backslashs,backslashes backsta,backseat backtacking,backpacking +backwad,backward +backwardss,backwards +backware,backward +backwark,backward +backwrad,backward baclony,balcony +bactracking,backtracking +bacup,backup badnits,bandits badnwagon,bandwagon badnwidth,bandwidth +bage,bag +bahaving,behaving +bahavior,behavior +bahavioral,behavioral +bahaviors,behaviors +bahaviour,behaviour +baisc,basic baiscly,basically +baised,raised bakc,back bakcers,backers +bakcrefs,backrefs +bakend,backend,baked +bakends,backends baksetball,basketball +bakup,backup +bakups,backups +bakward,backward +bakwards,backwards +balacing,balancing balanceada,balanced balanceado,balanced balanse,balances balcanes,balances +balck,black,balk balckberry,blackberry balcked,blacked balckhawks,blackhawks @@ -2490,18 +5221,26 @@ balcklist,blacklist balcksmith,blacksmith balconey,balcony balconny,balcony +balence,balance balitmore,baltimore ballisitc,ballistic ballistc,ballistic ballsitic,ballistic balnaced,balanced +baloon,balloon +baloons,balloons +balse,false balsphemy,blasphemy banannas,bananas +banch,branch,bench +banched,branched,benched +banches,branches,benches banditas,bandits bandiwdth,bandwidth bandwagoon,bandwagon bandwdith,bandwidth bandwidht,bandwidth +bandwidthm,bandwidth bandwitdh,bandwidth bandwith,bandwidth bangaldesh,bangladesh @@ -2519,9 +5258,10 @@ bankrupcy,bankruptcy bankruptsy,bankruptcy bankrupty,bankruptcy bankrutpcy,bankruptcy +banlance,balance banruptcy,bankruptcy baordwalk,boardwalk -baout,about +baout,about,bout baoynet,bayonet baptims,baptism baptisim,baptism @@ -2537,6 +5277,7 @@ barbarina,barbarian barbarions,barbarians barbaris,barbarians barbarisch,barbaric +barbedos,barbados barberians,barbarians barcelets,bracelets barceloneta,barcelona @@ -2548,29 +5289,46 @@ bargainning,bargaining bargani,bargain bargian,bargain bargianing,bargaining +bariier,barrier bariner,brainer baristia,barista barlkey,barkley +barnch,branch +barnched,branched +barncher,brancher +barnchers,branchers +barnches,branches +barnching,branching barrackus,barracks barracs,barracks barrakcs,barracks barrells,barrels +barriors,barriers barrles,barrels +barrriers,barriers barsita,barista bartendars,bartenders barvery,bravery +barycentic,barycentric +basci,basic bascially,basically bascily,basically +bascktrack,backtrack basektball,basketball +basf,base +basicallly,basically basicaly,basically basiclay,basically basicley,basically basicliy,basically +basiclly,basically basicly,basically basilcy,basically basiton,bastion baskteball,basketball basnhee,banshee +bassic,basic +bassically,basically bastane,bastante bastardes,bastards bastardos,bastards @@ -2578,6 +5336,18 @@ bastardous,bastards bastardus,bastards bastars,bastards bastino,bastion +bastract,abstract +bastracted,abstracted +bastracter,abstracter +bastracting,abstracting +bastraction,abstraction +bastractions,abstractions +bastractly,abstractly +bastractness,abstractness +bastractor,abstractor +bastracts,abstracts +bateries,batteries +batery,battery bathrom,bathroom bathrooom,bathroom batistia,batista @@ -2586,6 +5356,8 @@ batlimore,baltimore batsita,batista battailon,battalion battalin,battalion +battaries,batteries +battary,battery battelfield,battlefield battelfront,battlefront battelship,battleship @@ -2610,15 +5382,22 @@ bayblon,babylon baynoet,bayonet bayoent,bayonet bayonent,bayonet +bboolean,boolean +bbooleans,booleans bcak,back +bcause,because bceuase,because +beacaon,beacon +beacause,because beachead,beachhead beacuoup,beaucoup beacuse,because beahviour,behaviour beahviours,behaviours bealtes,beatles +beaon,beacon beardude,bearded +bearword,bareword beaslty,beastly beastiality,bestiality beastley,beastly @@ -2626,51 +5405,108 @@ beatels,beatles beatiful,beautiful beaucop,beaucoup beauitful,beautiful +beauracracy,bureaucracy beaurocracy,bureaucracy beaurocratic,bureaucratic +beause,because +beauti,beauty beautifullly,beautifully beautifuly,beautifully beautifyl,beautifully beautilful,beautifully +beautiy,beauty +beautyfied,beautified beautyfull,beautiful beautyfully,beautifully +beaviour,behaviour +bebongs,belongs +becaause,because +becacdd,because +becahse,because becamae,became -becames,becomes +becames,becomes,became +becaouse,because +becase,because becasue,because +becasuse,because +becauae,because +becauce,because +becaue,because +becaues,because +becaus,because +becausee,because +becauseq,because +becauses,because +becausw,because beccause,because +bechmark,benchmark +bechmarked,benchmarked +bechmarking,benchmarking +bechmarks,benchmarks becnhmark,benchmark becnhmarks,benchmarks +becoem,become becomeing,becoming becomming,becoming +becoms,becomes becouse,because +becoz,because +bector,vector +bectors,vectors becuaes,because becuasse,because becusae,because +becuse,because +becxause,because +beding,bedding,begging bedore,before beehtoven,beethoven -beeing,being +beeing,being,been +beeings,beings beethoveen,beethoven +beetween,between +beetwen,between +beffer,buffer befirend,befriend befoer,before +befor,before +beforehands,beforehand +beforere,before +befores,before +beforing,before befreind,befriend befried,befriend -beggin,begin +befure,before +beggin,begin,begging begginer,beginner begginers,beginners -begginig,begging +beggingin,beginning +begginging,beginning +begginig,begging,beginning beggining,beginning begginings,beginnings begginng,begging +begginnig,beginning +begginning,beginning beggins,begins +begiinning,beginning +beginer,beginner +begines,begins begining,beginning begininng,beginning begininngs,beginnings +beginn,begin beginnig,beginning +beginnin,beginning beginninng,beginnings beginnins,beginnings +beginnning,beginning +beginnnings,beginnings beglian,belgian beglium,belgium begnals,bengals +behabviour,behaviour +behaivior,behavior behaivor,behavior behaivors,behaviors behaivour,behaviour @@ -2678,6 +5514,9 @@ behaivours,behaviours behaviorial,behavioral behaviorly,behavioral behavios,behaviors +behavious,behaviour,behaviours +behavioutr,behaviour +behaviuor,behavior behavoir,behavior behavoiral,behavioral behavoirs,behaviors @@ -2686,14 +5525,29 @@ behavoiurs,behaviours behavorial,behavioral behavour,behaviour behavoural,behavioural +behavriour,behaviour +behavriours,behaviours +behinde,behind +behing,behind,being behngazi,benghazi behtesda,bethesda behvaiour,behaviour behvaiours,behaviours +behviour,behaviour +beiginning,beginning +beind,behind +beinning,beginning bejiing,beijing +bejond,beyond beleagured,beleaguered beleif,belief +beleifable,believable +beleife,belief,believe +beleifed,believed +beleifes,beliefs,believes +beleifing,believing beleifs,beliefs +beleiv,believe,belief beleivable,believable beleive,believe beleived,believed @@ -2704,49 +5558,88 @@ belgain,belgian belguim,belgium beliavable,believable beliebable,believable -beliefes,beliefs +beliefable,believable +beliefe,believe,belief +beliefed,believed +beliefes,beliefs,believes +beliefing,believing believeble,believable believr,believer believs,believes belifes,beliefs beligan,belgian beligum,belgium +beling,belong belittleing,belittling belittlling,belittling +beliv,believe,belief +belivable,believable belive,believe beliveable,believable -belived,believed +beliveably,believably +beliveble,believable +belivebly,believably +belived,believed,beloved beliveing,believing -belives,believes +belives,believes,beliefs +beliving,believing belligerant,belligerent belligerante,belligerent belligirent,belligerent bellweather,bellwether +belog,belong +beloging,belonging +belogs,belongs +belond,belong +beloning,belonging +belove,below,beloved +belown,belong belssings,blessings +belwo,below bemusemnt,bemusement benagls,bengals +benchamarked,benchmarked +benchamarking,benchmarking benchamrk,benchmark benchamrks,benchmarks benchmakrs,benchmarks benchmars,benchmarks +benchmkar,benchmark +benchmkared,benchmarked +benchmkaring,benchmarking +benchmkars,benchmarks +benchs,benches +benckmark,benchmark +benckmarked,benchmarked +benckmarking,benchmarking benckmarks,benchmarks +benechmark,benchmark +benechmarked,benchmarked +benechmarking,benchmarking +benechmarks,benchmarks benedicat,benedict benedickt,benedict benedit,benedict +beneeth,beneath benefecial,beneficial benefica,beneficial +benefical,beneficial beneficary,beneficiary beneficiul,beneficial benefitial,beneficial benefitical,beneficial beneifical,beneficial +beneits,benefits benelovent,benevolent +benerate,generate,venerate +benetifs,benefits benevalent,benevolent benevelant,benevolent benevelent,benevolent benevelont,benevolent benevloent,benevolent benevolant,benevolent +beng,being bengahzi,benghazi bengalas,bengals bengalos,bengals @@ -2758,21 +5651,31 @@ benghzai,benghazi benglas,bengals bengzhai,benghazi benhgazi,benghazi +benhind,behind benidect,benedict benificial,beneficial benifit,benefit +benifite,benefit +benifited,benefited +benifitial,beneficial benifits,benefits +benig,being benovelent,benevolent +beond,beyond beoynce,beyonce beraded,bearded berekley,berkeley +berforming,performing bergamont,bergamot berkelely,berkeley +berkley,berkeley bernouilli,bernoulli bersekr,berserk bersekrer,berserker berserkr,berserker berskerer,berserker +berween,between +besed,based beseige,besiege beseiged,besieged beseiging,besieging @@ -2782,32 +5685,68 @@ besteality,bestiality bestialiy,bestiality bestiallity,bestiality betales,beatles +beteeen,between beteen,between betehsda,bethesda +beter,better beteshda,bethesda +beteween,between bethdesa,bethesda bethedsa,bethesda bethesa,bethesda bethseda,bethesda betrayd,betrayed betrayeado,betrayed +betrween,between +bettern,better +bettery,better,battery +betwean,between +betwee,between +betweed,between +betweeen,between +betweem,between +betweend,between +betweeness,betweenness +betweent,between betwen,between +betwene,between +betwern,between beuatiful,beautiful beuatifully,beautifully -beucase,becuase +beucase,becuase,because +beuracracy,bureaucracy beuraucracy,bureaucracy beuraucratic,bureaucratic beuraucrats,bureaucrats +beutification,beautification +beutiful,beautiful +beutifully,beautifully +bever,never +bevore,before +bevorehand,beforehand +bevorhand,beforehand +beweeen,between beween,between bewteen,between +bewteeness,betweenness beyoncye,beyonce +beyong,beyond +beyound,beyond +bffer,buffer +bginning,beginning +bianries,binaries bianry,binary +biappicative,biapplicative bibilcal,biblical bicthes,bitches bicylces,bicycles +bidimentionnal,bidimensional +bidning,binding +bidnings,bindings bidrman,birdman biejing,beijing bifgoot,bigfoot +bigallic,bigalloc bigfooot,bigfoot bigining,beginning biginning,beginning @@ -2815,6 +5754,8 @@ bigorty,bigotry bigrading,brigading bigtoed,bigoted bigtory,bigotry +biinary,binary +bilangual,bilingual bilateraly,bilaterally bilbical,biblical billbaord,billboard @@ -2830,9 +5771,21 @@ billionarie,billionaire billionaries,billionaires billioniare,billionaire billioniares,billionaires +billon,billion bilsters,blisters bilzzard,blizzard bilzzcon,blizzcon +bimask,bitmask +bimillenia,bimillennia +bimillenial,bimillennial +bimillenium,bimillennium +bimontly,bimonthly +binairy,binary +binanary,binary +binar,binary +binay,binary +bindins,bindings +binidng,binding binominal,binomial biogted,bigoted biogtry,bigotry @@ -2842,16 +5795,21 @@ biologia,biological biologicaly,biologically biologiset,biologist biologiskt,biologist +bion,bio bioplar,bipolar biploar,bipolar birdamn,birdman birdges,bridges birgade,brigade birgading,brigading +birght,bright +birghten,brighten +birghter,brighter birghtest,brightest birghtness,brightness birhtday,birthday birhtdays,birthdays +biridectionality,bidirectionality birmignham,birmingham birmimgham,birmingham birmingharam,birmingham @@ -2859,14 +5817,29 @@ birsbane,brisbane birthdayers,birthdays birthdaymas,birthdays birthdsy,birthdays +bisct,bisect biseuxal,bisexual bisexaul,bisexual bisexuella,bisexual +bisines,business +bisiness,business +bisnes,business +bisness,business +bistream,bitstream +bisunes,business +bisuness,business +bitamps,bitmaps +bitap,bitmap bitcion,bitcoin bitcions,bitcoins bitcoints,bitcoins +bitfileld,bitfield +bitfilelds,bitfields bithced,bitched bithces,bitches +bitis,bits +bitmast,bitmask +bitnaps,bitmaps bitocin,bitcoin bitocins,bitcoins bitterseet,bittersweet @@ -2874,7 +5847,12 @@ bittersweat,bittersweet bittersweeet,bittersweet bitterswet,bittersweet bitterwseet,bittersweet +biult,built,build +bizare,bizarre +bizarely,bizarrely bizzare,bizarre +bject,object +bjects,objects blackade,blacked blackahwks,blackhawks blackbarry,blackberry @@ -2892,11 +5870,21 @@ blacklit,blacklist blackmsith,blacksmith blackshit,blacksmith blackshits,blacksmith +blackslashes,backslashes blacksmitch,blacksmith +blaclist,blacklist blacony,balcony blaim,blame blaimed,blamed +blak,black,blank blamethrower,flamethrower +blanace,balance +blance,balance,glance,lance +blanced,balanced,glanced,lanced +blances,balances,glances,lances +blancing,balancing,glancing,lancing +blanck,blank,black +blancked,blanked blankes,blankets blanketts,blankets blapshemy,blasphemy @@ -2906,25 +5894,65 @@ blasphemey,blasphemy blasphmey,blasphemy blatanlty,blatantly blatanty,blatantly +blatent,blatant +blatently,blatantly blatimore,baltimore +blbos,blobs +blcok,block +blcoks,blocks +bleading,bleeding blegian,belgian blegium,belgium +blessd,blessed blessins,blessings blessure,blessing +bletooth,bluetooth bleuberry,blueberry bleutooth,bluetooth +blindy,blindly blisteres,blisters blitzkreig,blitzkrieg blizzad,blizzard blizzcoin,blizzcon +bload,bloat +bloaded,bloated +blocack,blockack +bloccks,blocks +blocekd,blocked blochchain,blockchain blockcahin,blockchain blockchan,blockchain blockchian,blockchain blockeras,blockers blockes,blockers +blockhain,blockchain +blockhains,blockchains +blockin,blocking +bloddy,bloody +blodk,block +bloek,bloke +bloekes,blokes +bloeks,blokes +bloekss,blokes bloggare,blogger bloggeur,blogger +blohted,bloated +blok,block,bloke +blokc,block,bloke +blokcer,blocker +blokchain,blockchain +blokchains,blockchains +blokcing,blocking +blokcs,blocks,blokes +blokcss,blocks,blokes +bloked,blocked +bloker,blocker +bloking,blocking +bloks,blocks,blokes +blong,belong +blonged,belonged +blonging,belonging +blongs,belongs bloodboner,bloodborne bloodbonre,bloodborne bloodboorne,bloodborne @@ -2934,6 +5962,7 @@ bloodbrone,bloodborne bloodporne,bloodborne bloorborne,bloodborne bloster,bolster +bloted,bloated bluebarries,blueberries blueberies,blueberries blueberris,blueberries @@ -2944,17 +5973,28 @@ bluebrints,blueprints blueburries,blueberries blueprients,blueprints blueprintcss,blueprints +bluestooth,bluetooth bluetooh,bluetooth +bluetoot,bluetooth +bluetootn,bluetooth blugaria,bulgaria blulets,bullets +blured,blurred +blurr,blur,blurred +blutooth,bluetooth +bnecause,because +boads,boards boardband,broadband boardcast,broadcast boardcasting,broadcasting boardcasts,broadcasts boardway,broadway -boaut,bout +boaut,bout,boat,about +bobard,board,bombard bobmers,bombers bobybuilding,bodybuilding +bocome,become +boddy,body bodybuidling,bodybuilding bodybuildig,bodybuilding bodybuildng,bodybuilding @@ -2966,8 +6006,16 @@ bodyheight,bodyweight bodyweigt,bodyweight bodyweigth,bodyweight bodywieght,bodyweight +boffer,buffer +bofore,before +boggus,bogus +bogos,bogus +bointer,pointer +bolean,boolean +boleen,boolean bollcoks,bollocks bollocs,bollocks +bolor,color bombardeada,bombarded bombardeado,bombarded bombardement,bombardment @@ -2977,14 +6025,54 @@ bomberos,bombers bondary,boundary bonnano,bonanno bonsues,bonuses +bood,boot bookamrks,bookmarks +bookeeping,bookkeeping +bookkeeing,bookkeeping +bookkeeiping,bookkeeping +bookkepp,bookkeep +bookmakr,bookmark bookmakred,bookmarked bookmakrs,bookmarks +bookmar,bookmark bookmarkd,bookmarked bookmars,bookmarks +boold,bold,bool +booleam,boolean +booleamn,boolean +booleamns,booleans +booleams,booleans +booleanss,booleans +booleen,boolean +booleens,booleans +boolen,boolean +boolens,booleans +booltloader,bootloader +booltloaders,bootloaders +boomark,bookmark +boomarks,bookmarks boook,book +booolean,boolean +boooleans,booleans +boostrap,bootstrap +boostrapped,bootstrapped +boostrapping,bootstrapping +boostraps,bootstraps +booteek,boutique bootlaoder,bootloader +bootlaoders,bootloaders bootleader,bootloader +bootoloader,bootloader +bootom,bottom +bootraping,bootstrapping +bootsram,bootram +bootsrap,bootstrap +bootstap,bootstrap +bootstapped,bootstrapped +bootstapping,bootstrapping +bootstaps,bootstraps +boquet,bouquet +borad,board boradband,broadband boradcast,broadcast boradcasting,broadcasting @@ -2994,26 +6082,120 @@ borader,broader boradly,broadly boradwalk,boardwalk boradway,broadway +borded,boarded,border bordelrands,borderlands bordeom,boredom borderlads,borderlands borderlanders,borderlands borderlans,borderlands +bording,boarding bordlerands,borderlands +bordreline,borderline +bordrelines,borderlines boredoom,boredom +borgwasy,bourgeoisie borke,broke +borken,broken +borow,borrow bortherhood,brotherhood +borwser,browsers +borwsers,browsers boslter,bolster +bostom,boston,bottom +bothe,both +boths,both +botifies,notifies botivational,motivational bottelneck,bottleneck bottlebeck,bottleneck +bottlenck,bottleneck +bottlencks,bottlenecks +bottlenect,bottleneck +bottlenects,bottlenecks +bottlneck,bottleneck +bottlnecks,bottlenecks +bottomborde,bottomborder +bottome,bottom +botton,bottom,button +bottons,bottoms,buttons +botttom,bottom +bouce,bounce +bouces,bounces +boudaries,boundaries +boudary,boundary +bouding,bounding boudler,boulder +boudnaries,boundaries +boudnary,boundary +bouds,bounds +bouind,bound +bouinded,bounded +bouinding,bounding +bouinds,bounds bouldore,boulder +boun,bound +bounaaries,boundaries +bounaary,boundary +bounad,bound +bounadaries,boundaries +bounadary,boundary +bounaded,bounded +bounading,bounding +bounadries,boundaries +bounadry,boundary +bounads,bounds +bounardies,boundaries +bounardy,boundary +bounaries,boundaries +bounary,boundary +bounbdaries,boundaries +bounbdary,boundary boundaires,boundaries +boundares,boundaries +boundaryi,boundary +boundarys,boundaries +bounday,boundary +boundays,boundaries bounderies,boundaries +boundery,boundary +boundig,bounding +boundimg,bounding +boundrary,boundary +boundries,boundaries boundry,boundary +bounduaries,boundaries +bouned,bounded +boungaries,boundaries +boungary,boundary +boungin,bounding +boungind,bounding +bounhdaries,boundaries +bounhdary,boundary +bounidng,bounding +bouning,bounding bounites,bounties +bounnd,bound +bounnded,bounded +bounnding,bounding +bounnds,bounds +bounradies,boundaries +bounrady,boundary +bounraies,boundaries +bounraries,boundaries +bounrary,boundary +bounray,boundary +bouns,bounds +bounsaries,boundaries +bounsary,boundary +bounsd,bounds bounses,bonuses +bount,bound +bountries,boundaries +bountry,boundary +bounudaries,boundaries +bounudary,boundary +bounus,bonus +bouqet,bouquet bouregois,bourgeois bourgeios,bourgeois bourgeoius,bourgeois @@ -3022,9 +6204,17 @@ bourgoeis,bourgeois boutiqe,boutique boutnies,bounties boutqiue,boutique +bouund,bound +bouunded,bounded +bouunding,bounding +bouunds,bounds +bouy,buoy bouyancy,buoyancy bouyant,buoyant +boxe,boxes,box,boxer +boxs,box boyant,buoyant +boycot,boycott boycottting,boycotting boycutting,boycotting boyfirend,boyfriend @@ -3039,6 +6229,10 @@ braceletes,bracelets bracelettes,bracelets braceletts,bracelets bracelona,barcelona +bracese,braces +brach,branch +brackeds,brackets +brackground,background bradcast,broadcast bradfrod,bradford braevry,bravery @@ -3051,9 +6245,20 @@ brakedowns,breakdowns brakeout,breakout brakethrough,breakthrough brakley,barkley +brakpoint,breakpoint +brakpoints,breakpoints +brance,branch,brace,branches +branchces,branches +branchs,branches +branck,branch +branckes,branches +brancket,bracket +branckets,brackets +brane,brain branier,brainer braodband,broadband braodcast,broadcast +braodcasted,broadcasted braodcasting,broadcasting braodcasts,broadcasts braoden,broaden @@ -3063,6 +6268,7 @@ braodway,broadway brasillian,brazilian bratenders,bartenders braverly,bravery +brazeer,brassiere brazilains,brazilians brazileans,brazilians braziliaan,brazilians @@ -3072,13 +6278,19 @@ brazilias,brazilians braziliians,brazilians brazilions,brazilians brazillans,brazilians +brazillian,brazilian +bre,be,brie breadtfeeding,breastfeeding breakdows,breakdowns +breakes,breaks breakthorugh,breakthrough breakthough,breakthrough breakthroughts,breakthroughs breakthrouh,breakthrough +breakthruogh,breakthrough +breakthruoghs,breakthroughs breaktrhough,breakthrough +breal,break breastfeading,breastfeeding breastfeedig,breastfeeding breastfeeing,breastfeeding @@ -3088,12 +6300,21 @@ breathos,breaths breathtakng,breathtaking breatsfeeding,breastfeeding brednan,brendan +breef,brief,beef +breefly,briefly +brefore,before breif,brief breifly,briefly brekaout,breakout +brekpoint,breakpoint +brekpoints,breakpoints brendamn,brendan breserk,berserk breserker,berserker +bresh,brush,fresh +breshed,brushed +breshes,brushes +breshing,brushing brethen,brethren bretheren,brethren breweres,brewers @@ -3101,6 +6322,7 @@ brewerey,brewery brewerks,brewers brewerys,brewers brewrey,brewery +brfore,before briagde,brigade brianer,brainer brianwashed,brainwashed @@ -3108,16 +6330,24 @@ brianwashing,brainwashing bridaging,brigading bridman,birdman brielfy,briefly +brievely,briefly brigaged,brigade brigated,brigade +brigde,bridge brigdes,bridges +brige,bridge +briges,bridges +brighness,brightness brightern,brighten brightn,brighten +brightnesss,brightness brightoner,brighten +brigth,bright brigthen,brighten brigthest,brightest brigthness,brightness briliant,brilliant +brilinear,bilinear brillaince,brilliance brillaintly,brilliantly brillant,brilliant @@ -3126,6 +6356,8 @@ brillianty,brilliantly brilliany,brilliantly brimestone,brimstone brimingham,birmingham +bringin,bringing +bringtofont,bringtofront brisben,brisbane bristool,bristol brithday,birthday @@ -3137,32 +6369,73 @@ briused,bruised briuser,bruiser briusers,bruisers briuses,bruises +brnach,branch +brnaches,branches broacasted,broadcast broadacasting,broadcasting broadbad,broadband +broadcas,broadcast +broadcase,broadcast broadcasing,broadcasting broadcastes,broadcasts +broadcasti,broadcast broadcastors,broadcasts -broadcat,broadcasts +broadcat,broadcasts,broadcast broadley,broadly broadwalk,boardwalk broady,broadly +broardcast,broadcast +broblematic,problematic +brocher,brochure +brocken,broken +brockend,broken +brockened,broken +brocolee,broccoli brocoli,broccoli brocolli,broccoli brodaway,broadway +brodcast,broadcast broderlands,borderlands +broked,broken +brokem,broken +brokend,broken +brokened,broken +brokeness,brokenness broncoes,broncos +bronken,broken bronocs,broncos +brosable,browsable +brose,browse,rose +brosed,browsed,rosed +broser,browser +brosers,browsers +brosing,browsing +broswable,browsable +broswe,browse +broswed,browsed +broswer,browser +broswers,browsers broswing,browsing brotherhod,brotherhood brotherhoood,brotherhood brotherood,brotherhood brotherwood,brotherhood +brouter,router +brower,browser +browers,browsers browine,brownie browines,brownies +browing,browsing browisng,browsing brownei,brownie brownis,brownies +browseable,browsable +browswable,browsable +browswe,browse +browswed,browsed +browswer,browser +browswers,browsers +browswing,browsing brtually,brutally bruglar,burglar brugundy,burgundy @@ -3183,8 +6456,17 @@ brutailty,brutality brutallity,brutally brutallly,brutally brutaly,brutally +brwosable,browsable +brwose,browse +brwosed,browsed +brwoser,browser +brwosers,browsers +brwosing,browsing btiched,bitched btiches,bitches +btye,byte +btyes,bytes +buad,baud bubbels,bubbles bubblews,bubbles buddah,buddha @@ -3205,27 +6487,72 @@ buearucrats,bureaucrats bueraucracy,bureaucracy bueraucratic,bureaucratic bueraucrats,bureaucrats +bufefr,buffer +bufer,buffer +bufers,buffers +buffereed,buffered +bufferent,buffered +bufferred,buffered +buffeur,buffer +bufffer,buffer +bufffers,buffers +buffor,buffer +buffors,buffers +buffr,buffer +buffred,buffered +buffring,buffering +bufufer,buffer bugdets,budgets +buggest,biggest buglaria,bulgaria +bugous,bogus +buguous,bogus +bugus,bogus buhddism,buddhism buhddist,buddhist buhddists,buddhists +buid,build +buiding,building buidlers,builders buidling,building buidlings,buildings +buiild,build +buik,bulk +buil,build,built +builded,built buildes,builders buildins,buildings +buillt,built +builter,builder +builters,builders +buipd,build buisness,business buisnesses,businesses buisnessman,businessman buisnessmen,businessmen +buissiness,business +buissinesses,businesses +buit,built +buitin,builtin +buitins,builtins +buitlin,builtin +buitlins,builtins +buitton,button +buittons,buttons bulagria,bulgaria +buld,build +bulding,building +bulds,builds bulgaira,bulgaria bulgara,bulgaria bulgariska,bulgaria +bulid,build buliders,builders buliding,building bulidings,buildings +bulids,builds +bulit,built +bulle,bullet bullerproof,bulletproof bullest,bullets bulletbroof,bulletproof @@ -3234,8 +6561,16 @@ bulletprof,bulletproof bulletproff,bulletproof bulletprooof,bulletproof bulletprrof,bulletproof +bulletted,bulleted bulletts,bullets bullitproof,bulletproof +bult,built +bultin,builtin +bumb,bump +bumpded,bumped +bumpted,bumped +bundel,bundle +bundeled,bundled buoancy,buoyancy bureacuracy,bureaucracy bureaocracy,bureaucracy @@ -3254,17 +6589,19 @@ bureaucratisch,bureaucratic bureaucratische,bureaucratic bureaucratius,bureaucrats bureaucrazy,bureaucracy +bureauracy,bureaucracy bureuacracy,bureaucracy bureuacratic,bureaucratic bureuacrats,bureaucrats burgunday,burgundy burgundry,burgundy burguny,burgundy -buring,burying +buring,burying,burning,burin,during buriser,bruiser burisers,bruisers burlgar,burglar burnign,burning +burocratic,bureaucratic burried,buried burriots,burritos burritio,burrito @@ -3276,9 +6613,10 @@ burssels,brussels burtality,brutality burtally,brutally burtsing,bursting +burtst,burst burueacrats,bureaucrats busines,business -busineses,business +busineses,business,businesses businesman,businessman businesmen,businessmen businessa,businessman @@ -3291,8 +6629,11 @@ busness,business busniessmen,businessmen busrting,bursting bussiness,business +bussy,busy butcherd,butchered buthcered,butchered +buton,button +butons,buttons butterey,buttery butterfies,butterflies butterfiles,butterflies @@ -3302,11 +6643,26 @@ butterfries,butterflies butterfy,butterfly butterlfies,butterflies butterlfy,butterfly +butterly,butterfly butterry,buttery butthoe,butthole butthoel,butthole +buttom,button,bottom +buttoms,buttons,bottom +buttosn,buttons buttrey,buttery +buttton,button +butttons,buttons +buufers,buffers +buuild,build +buuilds,builds +bve,be +bwtween,between bycicles,bicycles +bypas,bypass +bypased,bypassed +bypasing,bypassing +byteoder,byteorder cababge,cabbage cababilities,capabilities cabbagge,cabbage @@ -3317,8 +6673,31 @@ cabines,cabinets cabinettas,cabinets cabniet,cabinet cabniets,cabinets +cacahe,cache +cacahes,caches cacausian,caucasian +cace,cache +cach,catch,cache +cachable,cacheable +cacheed,cached +cacheing,caching +cachline,cacheline +cachse,cache,caches +cacl,calc +caclate,calculate caclium,calcium +cacluate,calculate +cacluated,calculated +cacluater,calculator +cacluates,calculates +cacluating,calculating +cacluation,calculation +cacluations,calculations +cacluator,calculator +caclucate,calculate +caclucation,calculation +caclucations,calculations +caclucator,calculator caclulate,calculate caclulated,calculated caclulating,calculating @@ -3328,17 +6707,68 @@ caclulator,calculator caclulators,calculators caclulus,calculus cacuasian,caucasian +caculate,calculate +caculated,calculated caculater,calculator +caculates,calculates +caculating,calculating +caculation,calculation +caculations,calculations +caculator,calculator cacuses,caucuses +cadidate,candidate +caefully,carefully cafeteira,cafeteria cafetera,cafeteria cafetiera,cafeteria caffeen,caffeine caffeinne,caffeine caffinee,caffeine +cahacter,character +cahacters,characters +cahange,change +cahanged,changed +cahanges,changes +cahanging,changing +cahannel,channel +caharacter,character +caharacters,characters +caharcter,character +caharcters,characters +cahc,cache +cahce,cache +cahced,cached +cahces,caches +cahche,cache cahched,cached +cahchedb,cachedb +cahches,caches +cahcing,caching +cahcs,caches +cahdidate,candidate +cahdidates,candidates +cahe,cache +cahes,caches +cahgned,changed +cahgnes,changes +cahgning,changing +cahhel,channel +cahhels,channels +cahined,chained +cahing,caching +cahining,chaining +cahnge,change +cahnged,changed +cahnges,changes +cahnging,changing +cahnnel,channel +cahnnels,channels cahotic,chaotic +cahr,char +cahracter,character cahracters,characters +cahrging,charging +cahrs,chars cahsier,cashier cahsiers,cashiers cailbration,calibration @@ -3346,22 +6776,38 @@ cailbre,calibre cainster,canister calaber,caliber calagry,calgary +calalog,catalog calback,callback calbiration,calibration calbire,calibre +calcable,calculable +calcalate,calculate +calciulate,calculate +calciulating,calculating +calclation,calculation +calcluate,calculate +calcluated,calculated +calcluates,calculates calcluations,calculation calcluator,calculators +calcualation,calculation calcualte,calculate calcualted,calculated +calcualter,calculator +calcualtes,calculates calcualting,calculating -calcualtion,calculations +calcualtion,calculations,calculation calcualtions,calculations calcualtor,calculator calcualtors,calculators +calcuate,calculate +calcuations,calculations calcuim,calcium calculador,calculator +calculaion,calculation calcular,calculator calcularon,calculator +calculatble,calculatable,calculable calculater,calculator calculaters,calculators calculatin,calculations @@ -3369,13 +6815,37 @@ calculationg,calculating calculatios,calculators calculatoare,calculator calculatons,calculations +calculatted,calculated +calculatter,calculator +calculattion,calculation +calculattions,calculations +calculaution,calculation +calculautions,calculations +calculcate,calculate +calculcation,calculation +calculed,calculated calculs,calculus +calcultate,calculate +calcultated,calculated +calcultater,calculator +calcultating,calculating +calcultator,calculator +calculting,calculating +calculuations,calculations +calcurate,calculate +calcutated,calculated +caleed,called +caler,caller +calescing,coalescing calgarry,calgary +caliased,aliased calibartion,calibration calibler,caliber calibraiton,calibration calibratin,calibration calibraton,calibration +calibrte,calibrate +calibrtion,calibration calicum,calcium califnoria,californian califonria,californian @@ -3397,7 +6867,34 @@ californnia,californian califronia,california califronian,californian caligraphy,calligraphy +calilng,calling +caliming,claiming +caling,calling,scaling,culling caliofrnia,californian +callabck,callback +callabcks,callbacks +callack,callback +callbacl,callback +callbacsk,callback +callbak,callback +callbakc,callback +callbakcs,callbacks +callbck,callback +callcack,callback +callcain,callchain +calld,called +calle,called +callef,called +calles,calls +callibrated,calibrated +callibration,calibration +callibri,calibri +callig,calling +callint,calling +callled,called +calllee,callee +calloed,called +callsr,calls caloires,calories calrification,clarification calrify,clarify @@ -3405,11 +6902,16 @@ calrifying,clarifying calrity,clarity calrkson,clarkson calroies,calories +calss,calls,class +calsses,classes calssification,classification calssified,classified calssify,classify +calucate,calculate caluclate,calculate caluclated,calculated +caluclater,calculator +caluclates,calculates caluclating,calculating caluclation,calculation caluclations,calculations @@ -3417,10 +6919,15 @@ caluclator,calculator caluclators,calculators caluculate,calculate caluculated,calculated +calue,value caluiflower,cauliflower calulate,calculate calulated,calculated calulater,calculator +calulates,calculates +calulating,calculating +calulation,calculation +calulations,calculations caluses,clauses calymore,claymore camapign,campaign @@ -3435,6 +6942,7 @@ cambride,cambridge cambrigde,cambridge cambrige,cambridge camoflage,camouflage +camoflague,camouflage camofluage,camouflage camoufalge,camouflage camouflague,camouflage @@ -3452,6 +6960,7 @@ campaing,campaign campainging,campaigning campaings,campaigns campains,campaigns +camparing,comparing camperas,campers camperos,campers campiagns,campaigns @@ -3459,30 +6968,49 @@ campusers,campuses campuss,campuses camrbidge,cambridge canadains,canadians +canadan,canadian canadianese,canadians canadias,canadians cananbis,cannabis +cancelability,cancellability +cancelaltion,cancelation cancelas,cancels +cancelations,cancellations canceles,cancels cancellato,cancellation +cancelles,cancels cancells,cancels canceltation,cancellation canceres,cancers cancerns,cancers cancerus,cancers +cances,cancel +cancl,cancel +cancle,cancel +cancled,canceled cancles,cancels cancres,cancers cancuks,canucks candadate,candidate +candadates,candidates candiate,candidate +candiates,candidates candidatas,candidates candidats,candidates candidatxs,candidates candidiate,candidate +candidiates,candidates candiens,candies +candinate,candidate +candinates,candidates canditates,candidates +cange,change +canged,changed +canidate,candidate +canidates,candidates canides,candies canistre,canister +cann,can cannabil,cannibal cannabilism,cannibalism cannabolism,cannibalism @@ -3500,34 +7028,70 @@ cannister,canister cannisters,canisters cannnot,cannot cannobalism,cannibalism +cannobt,cannot cannoical,canonical cannonical,canonical +cannonicalize,canonicalize cannotation,connotation cannotations,connotations +cannott,cannot +canonalize,canonicalize +canonalized,canonicalized +canonalizes,canonicalizes +canonalizing,canonicalizing canoncial,canonical +canonicalizations,canonicalization +canonival,canonical +canot,cannot canrage,carnage cansiter,canister +canvase,canvas caost,coast +capabable,capable capabality,capability +capabicity,capability +capabiities,capabilities +capabiity,capability +capabilies,capabilities +capabiliites,capabilities capabilites,capabilities +capabilitieis,capabilities +capabilitiies,capabilities +capabilitires,capabilities capabilitiy,capability capabillity,capability +capabilties,capabilities +capabiltity,capability capabiltiy,capability +capabilty,capability +capabitilies,capabilities +capablilities,capabilities +capablities,capabilities +capablity,capability capacators,capacitors capacitaron,capacitor capaciters,capacitors capacitores,capacitors +capaciy,capacity capactior,capacitor capactiors,capacitors +capalize,capitalize +capalized,capitalized +capapbilities,capabilities capasitors,capacitors +capatibilities,capabilities capatilism,capitalism capatilist,capitalist capatilists,capitalists capatilization,capitalization capatilize,capitalize capatilized,capitalized +capbability,capability +capbale,capable +capela,capella caperbility,capability capialized,capitalized +capibilities,capabilities capible,capable capicator,capacitor capicators,capacitors @@ -3563,6 +7127,7 @@ capitolize,capitalize capitolized,capitalized capitulo,capitol capmbell,campbell +cappable,capable caprenter,carpenter capsuels,capsules capsulers,capsules @@ -3570,6 +7135,7 @@ capsulets,capsules capsuls,capsules capsulse,capsules capsumel,capsule +captable,capable captainers,captains captais,captains capteurs,captures @@ -3584,14 +7150,21 @@ captials,capitals captians,captains captiol,capitol captivitiy,captivity +captrure,capture captued,captured capturd,captured capusle,capsule capusles,capsules +caputre,capture caputres,captures +caputure,capture carachter,character caraciture,caricature +caracter,character +caractere,character +caracteristic,characteristic caracterized,characterized +caracters,characters carange,carnage carbien,carbine carbohdyrates,carbohydrates @@ -3600,7 +7173,8 @@ carbohydrats,carbohydrates carbohyrdate,carbohydrates carbohyrdates,carbohydrates carboyhdrates,carbohydrates -carcas,carcass +carbus,cardbus +carcas,carcass,caracas carciature,caricature cardaic,cardiac cardbaord,cardboard @@ -3620,12 +7194,14 @@ cardiovasuclar,cardiovascular cardnial,cardinal cardnials,cardinals careflly,carefully -carefull,careful +carefull,careful,carefully carefullly,carefully carefuly,carefully careing,caring +carfull,careful cariacture,caricature cariactures,caricature +cariage,carriage caricate,caricature caricatore,caricature caricaturale,caricature @@ -3636,9 +7212,11 @@ cariciture,caricature caricuture,caricature caridac,cardiac caridgan,cardigan +caridge,carriage caridnal,cardinal caridnals,cardinals caridovascular,cardiovascular +cariier,carrier carinval,carnival carismatic,charismatic carloina,carolina @@ -3646,8 +7224,8 @@ carmalite,carmelite carmtan,cartman carnagie,carnegie carnberry,cranberry -carnege,carnage -carnige,carnage +carnege,carnage,carnegie +carnige,carnage,carnegie carnigie,carnegie carniverous,carnivorous carnvial,carnival @@ -3656,17 +7234,26 @@ carolinia,carolina carpetner,carpenter carptener,carpenter carreer,career +carreid,carried carrers,careers +carriadge,carriage carribbean,caribbean carribean,caribbean +carridge,carriage,cartridge +carrien,carrier +carrige,carriage carrotts,carrots carrotus,carrots +carrrier,carrier +carryintg,carrying +carryng,carrying cartdridge,cartridge cartdrige,cartridge cartdriges,cartridges cartells,cartels carthagian,carthaginian carthographer,cartographer +cartiesian,cartesian cartilege,cartilage cartilidge,cartilage cartirdge,cartridge @@ -3682,10 +7269,14 @@ cartrigdes,cartridges cartrige,cartridge carvinal,carnival caryons,crayons +caryy,carry casaulity,causality casaulties,casualties casaulty,casualty +cascace,cascade +caselessely,caselessly casette,cassette +cashe,cache casheir,cashier casheirs,cashiers cashieer,cashier @@ -3721,12 +7312,13 @@ cataclysym,cataclysm catacylsm,cataclysm catacyslm,cataclysm catagorically,categorically +catagorie,category,categories catagories,categories catagorized,categorized catagory,category catalcysm,cataclysm catalgoue,catalogue -cataline,catiline +cataline,catiline,catalina cataloge,catalogue catalsyt,catalyst catapillar,caterpillar @@ -3738,20 +7330,36 @@ catastraphe,catastrophe catastraphic,catastrophic catastrohpe,catastrophe catastrohpic,catastrophic +catastronphic,catastrophic catastrope,catastrophe catastrophie,catastrophe catastrophies,catastrophe catastrophize,catastrophe catastropic,catastrophic +catastropically,catastrophically catastrphe,catastrophe +catastrphic,catastrophic cataylst,catalyst +catche,catch +catched,caught +catchi,catch +catchs,catches +categogical,categorical +categogically,categorically +categogies,categories +categogy,category categoricaly,categorically categorice,categorize +categorie,category,categories categoried,categorized categoriei,categorize categoriezed,categorized categroized,categorized +cateogrical,categorical +cateogrically,categorically +cateogries,categories cateogrize,categorized +cateogry,category catepillar,caterpillar catepillars,caterpillars catergorize,categorize @@ -3762,6 +7370,10 @@ caterpilars,caterpillars caterpiller,caterpillar caterpillers,caterpillars catestrophic,catastrophic +catgorical,categorical +catgorically,categorically +catgories,categories +catgory,category cathderal,cathedral catherdal,cathedral cathlic,catholic @@ -3784,8 +7396,12 @@ catistrophic,catastrophic cativating,activating catlayst,catalyst catogerized,categorized +catory,factory catostraphic,catastrophic catostrophic,catastrophic +catpture,capture +catpure,capture +catpured,captured catterpilar,caterpillar catterpilars,caterpillars catterpillar,caterpillar @@ -3794,17 +7410,61 @@ cattleship,battleship caucaisan,caucasian caucasain,caucasian caucasin,caucasian +caucasion,caucasian +cauched,caught +caugt,caught +cauhgt,caught cauilflower,cauliflower +cauing,causing caulfilower,cauliflower cauncks,canucks causacian,caucasian causailty,causality causalties,casualties causalty,casualty +causees,causes +causion,caution +causioned,cautioned +causions,cautions +causious,cautious cautionsly,cautiously +cavaet,caveat +cavaets,caveats cavarly,cavalry cavlary,cavalry -ceasar,cesar +ccahe,cache +ccale,scale +ccertificate,certificate +ccertificated,certificated +ccertificates,certificates +ccertification,certification +ccessible,accessible +cche,cache +cconfiguration,configuration +ccordinate,coordinate +ccordinates,coordinates +ccordinats,coordinates +ccoutant,accountant +cdecompress,decompress +ceartype,cleartype +ceasar,cesar,cesar +ceate,create +ceated,created +ceates,creates +ceating,creating +ceation,creation +ceck,check +cecked,checked +cecker,checker +cecking,checking +cecks,checks +cedential,credential +cedentials,credentials +cehck,check +cehcked,checked +cehcker,checker +cehcking,checking +cehcks,checks celcius,celsius celebartion,celebrations celebirties,celebrities @@ -3826,9 +7486,12 @@ celestail,celestial celibrations,celebrations celisus,celsius celitcs,celtics +celles,cells cellpading,cellpadding +cellst,cells cellulaire,cellular cellural,cellular +cellxs,cells celsuis,celsius celullar,cellular celverly,cleverly @@ -3836,34 +7499,52 @@ cementary,cemetery cemetarey,cemetery cemetaries,cemeteries cemetary,cemetery +cenario,scenario +cenarios,scenarios +cencter,center cencus,census +cengter,center cenitpede,centipede +censequence,consequence censorhsip,censorship -censur,censor +censur,censor,censure censurship,censorship +centain,certain cententenial,centennial centepide,centipede +centerd,centered centeres,centers centerns,centers centipeddle,centipede centipedle,centipede centipeed,centipede +centisencond,centisecond +centisenconds,centiseconds centrase,centres +centrifugeable,centrifugable +centrigrade,centigrade centruies,centuries centruy,century centuties,centuries centuty,century +cerate,create ceratine,creatine cerberal,cerebral cerbreus,cerberus cerbures,cerberus cercumstance,circumstance +cereates,creates cerebrawl,cerebral ceremone,ceremonies ceremonias,ceremonies ceremoniis,ceremonies ceremonije,ceremonies -cerification,verification +cerification,verification,certification +cerifications,certifications,verifications +cerified,certified,verified +cerifies,certifies,verifies +cerify,certify,verify +cerifying,certifying,verifying cerimonial,ceremonial cerimonies,ceremonies cerimonious,ceremonious @@ -3871,29 +7552,110 @@ cerimony,ceremony ceritfication,certifications cermaic,ceramic ceromony,ceremony +certaily,certainly +certaincy,certainty certainity,certainty certainlyt,certainty +certaint,certain certaintity,certainty certainy,certainty +certaion,certain +certan,certain certanity,certainty +certficate,certificate +certficated,certificated +certficates,certificates +certfication,certification +certfications,certifications +certficiate,certificate +certficiated,certificated +certficiates,certificates +certficiation,certification +certficiations,certifications +certfied,certified +certfy,certify certian,certain +certianly,certainly certianty,certainty +certicate,certificate +certicated,certificated +certicates,certificates +certication,certification +certifacte,certificate +certifacted,certificated +certifactes,certificates +certifaction,certification +certifcate,certificate +certifcated,certificated +certifcates,certificates +certifcation,certification +certifciate,certificate +certifciated,certificated +certifciates,certificates +certifciation,certification +certifiate,certificate +certifiated,certificated +certifiates,certificates +certifiating,certificating +certifiation,certification +certifiations,certifications certificaat,certificate certificaiton,certification certificare,certificate +certificat,certificate +certificatd,certificated +certificatin,certificating,certification certificationkits,certifications certificato,certification +certificaton,certification certificats,certificates +certifice,certificate +certificed,certificated +certifices,certificates certificiate,certificate -cervial,cervical +certificion,certification +certifificate,certificate +certifificated,certificated +certifificates,certificates +certifification,certification +certiticate,certificate +certiticated,certificated +certiticates,certificates +certitication,certification +cervial,cervical,servile,serval cessationalism,sensationalism cessationalist,sensationalist cesspol,cesspool cesspoool,cesspool cetlics,celtics +cetrainly,certainly +cetting,setting +cgywin,cygwin +chaarges,charges +chacacter,character +chacacters,characters +chache,cache +chached,cached +chacheline,cacheline +chaeck,check +chaecked,checked +chaecker,checker +chaecking,checking +chaecks,checks +chage,change,charge +chaged,changed,charged +chages,changes,charges +chaging,changing,charging +chagne,change +chagned,changed +chagnes,changes +chahged,changed +chaied,chained +chaing,chain chairmain,chairman chairtable,charitable chalenging,challenging +challanage,challenge challange,challenge challanged,challenged challanges,challenges @@ -3931,26 +7693,80 @@ championsips,championships championsship,championships champiosnhip,championships champoinship,championship +chanceled,canceled +chanceling,canceling chanceller,chancellor chancellour,chancellor +chanched,changed chancillor,chancellor +chancnel,channel,cancel chandlure,chandler +chane,change,chain +chaned,changed,chained +chaneged,changed +chanel,channel +chanell,channel +chanels,channels changable,changeable +changeing,changing +changged,changed +changlog,changelog +changuing,changing +chanined,chained +chaning,chaining,changing +chaninging,changing chanisaw,chainsaw chanlder,chandler +chanllenge,challenge +chanllenging,challenging +channe,channel +channeles,channels +channes,channels,chances,changes +channl,channel +channle,channel +channles,channels +channnel,channel +channnels,channels chanpionship,championship chanpionships,championships chansellor,chancellor +chanses,chances +chaper,chapter +characaters,characters +characer,character +characers,characters +characeter,character +characeters,characters +characetrs,characters +characher,character +charachers,characters charachter,character charachters,characters +characstyle,charstyle +charactar,character charactaristic,characteristic charactaristics,characteristics charactarization,characterization charactarize,characterize charactarized,characterized +charactars,characters +characte,character +charactear,character +charactears,characters +characted,character +characteds,characters +characteer,character +characteers,characters +characteisation,characterisation +characteization,characterization +characteor,character +characteors,characters characterazation,characterization charactere,characterize +characteres,characters characterisic,characteristic +characterisically,characteristically +characterisicly,characteristically characterisics,characteristics characterisitc,characteristics characterisitcs,characteristics @@ -3958,33 +7774,84 @@ characterisitic,characteristic characterisitics,characteristics characteristc,characteristics characteristcs,characteristics +characteristicly,characteristically characterists,characteristics characteristsics,characteristic characteritics,characteristic characterizarion,characterization characterizaton,characterization charactersistic,characteristic +charactersistically,characteristically +charactersistics,characteristics charactersitic,characteristics charactersitics,characteristics +charactersm,characters +characterss,characters +characterstic,characteristic +characterstically,characteristically +characterstics,characteristics +charactertistic,characteristic +charactertistically,characteristically +charactertistics,characteristics characterz,characterize +charactes,characters +charactet,character +characteter,character +characteteristic,characteristic +characteteristics,characteristics +characteters,characters +charactetistic,characteristic +charactetistics,characteristics +charactetr,character +charactetrs,characters +charactets,characters +characther,character charactor,character charactoristics,characteristics charactors,characters +charactristic,characteristic +charactristically,characteristically +charactristics,characteristics +charactrs,characters +characts,characters +characture,character +charakter,character charakters,characters +chararacter,character +chararcter,character +charas,chars +charascters,characters charasmatic,charismatic charasteristic,characteristics charatable,charitable +charater,character +charaterize,characterize charaterized,characterized +charaters,characters +charator,character +charators,characters charcaol,charcoal +charcater,character charcol,charcoal +charcter,character +charcters,characters +charctor,character +charctors,characters +charecter,character charecteristic,characteristic charecteristics,characteristics charecterization,characterization charecters,characters +charector,character chargehr,charger chargeur,charger +chargind,charging +charicter,character charicterization,characterization charicterized,characterized +charicters,characters +charictor,character +charictors,characters chariman,chairman charimastic,charismatic charimsa,charisma @@ -3993,30 +7860,76 @@ charismastic,charismatic charismatisch,charismatic charistics,characteristics charitible,charitable +charizma,charisma charmisa,charisma charocal,charcoal charsima,charisma charsimatic,charismatic chartiable,charitable +chartroose,chartreuse chasiers,cashiers chasiss,chassis -chasr,chaser +chasnge,change,changes +chasr,chaser,chase chassids,chassis chassies,chassis +chassy,chassis +chatacter,character +chatacters,characters +chatch,catch +chatched,caught,chatted chatedral,cathedral +chater,chapter chatoic,chaotic chatolic,catholic chatolics,catholics +chawk,chalk +chcek,check +chceked,checked +chceking,checking +chceks,checks +chck,check +chckbox,checkbox chcukles,chuckles +cheapeast,cheapest +cheatta,cheetah +chec,check +checg,check +checged,checked +chech,check,czech +checheckpoit,checkpoint +checheckpoits,checkpoints +cheched,checked +cheching,checking +chechk,check chechpoint,checkpoint +chechs,checks +checkalaises,checkaliases checkare,checker +checkcsum,checksum +checkd,checked checkear,checker +checkes,checks +checkk,check checkmeat,checkmate +checkoslovakia,czechoslovakia checkpiont,checkpoint +checkpoing,checkpoint checkpoins,checkpoints checkpointusa,checkpoints checkpoit,checkpoints checkponts,checkpoints +checkstum,checksum +checkstuming,checksumming +checkstumming,checksumming +checkstums,checksums +checksume,checksum +checksumed,checksummed +checksuming,checksumming +checkum,checksum +checkums,checksums +checkuot,checkout +cheduling,scheduling cheeots,cheetos cheerleadra,cheerleader cheerlearder,cheerleader @@ -4040,14 +7953,26 @@ cheesees,cheeses cheeseface,cheesecake cheeseus,cheeses cheesse,cheeses +cheeta,cheetah cheetoos,cheetos cheezeburger,cheeseburger cheezeburgers,cheeseburgers cheezecake,cheesecake cheif,chief cheifs,chiefs +chek,check +chekc,check chekcer,checker +chekcing,checking chekcmate,checkmate +chekd,checked +cheked,checked +chekers,checkers +cheking,checking +cheks,checks +cheksum,checksum +cheksums,checksums +chello,cello chelsae,chelsea chemcial,chemical chemcially,chemically @@ -4055,18 +7980,22 @@ chemestry,chemistry chemicaly,chemically chemisty,chemistry chemsitry,chemistry +chenged,changed +chennel,channel chernboyl,chernobyl chernobl,chernobyl chernobly,chernobyl chernoybl,chernobyl chernyobl,chernobyl cheronbyl,chernobyl +chescksums,checksums cheslea,chelsea chiansaw,chainsaw chidlbirth,childbirth chidlfree,childfree chidlish,childish chidlrens,childrens +chidren,children chiense,chinese chihauhua,chihuahua chihuaha,chihuahua @@ -4076,32 +8005,51 @@ chihuahuita,chihuahua childbird,childbirth childbrith,childbirth childen,children +childern,children childerns,childrens childisch,childish +childlren,children childrends,childrens childrenis,childrens childrenmrs,childrens childrents,childrens -childres,childrens +childres,childrens,children childresn,childrens +childs,children +chiled,child,chilled +chiledren,children chillade,chilled chillead,chilled chillend,chilled +chilren,children chilvary,chivalry chimeny,chimney chinees,chinese +chineese,chinese chinesse,chinese chinmey,chimney +chiop,chip,chop +chiper,cipher,chipper,chimer +chipers,ciphers,chippers,chimers +chipersuite,ciphersuite +chipersuites,ciphersuites +chipertext,ciphertext +chipertexts,ciphertexts chipest,chipset +chipet,chipset +chipslect,chipselect +chipstes,chipsets chirstian,christian chirstianity,christianity chirstians,christians chirstmas,christmas chispet,chipset chiuhahua,chihuahua +chiuldren,children chivaly,chivalry chivarly,chivalry chivlary,chivalry +chked,checked chlesea,chelsea chlidfree,childfree chlidish,childish @@ -4109,9 +8057,14 @@ chlidrens,childrens chloesterol,cholesterol chlroine,chlorine chmabers,chambers +chnage,change +chnages,changes +chnge,change +chnnel,channel choatic,chaotic chocalates,chocolates chocies,choices +choclate,chocolate chocloate,chocolate chocloates,chocolates chocoalte,chocolate @@ -4127,6 +8080,10 @@ chocolotes,chocolates chocolste,chocolates choesive,cohesive choicers,choices +choicing,choosing +choise,choice +choises,choices +choising,choosing cholesteral,cholesterol cholestoral,cholesterol cholestorol,cholesterol @@ -4134,13 +8091,33 @@ cholestrol,cholesterol cholocate,chocolate cholosterol,cholesterol cholrine,chlorine +chooose,choose +choos,choose +choosed,chose,chosen choosen,chosen +chopipng,chopping +chopy,choppy,chop chorline,chlorine chormosome,chromosome chormosomes,chromosomes chornicles,chronicles chornological,chronological +choronological,chronological +chosed,chose +choser,chooser +chosing,choosing +chossen,chosen +chould,should,could +chouse,choose,chose,choux chracter,character +chracters,characters +chractor,character +chractors,characters +chrash,crash,thrash,trash +chrashed,crashed,thrashed,trashed +chrashes,crashes,thrashes,trashes +chrashing,crashing,thrashing,trashing +chrashs,crashes,thrashes,trashes chrenobyl,chernobyl chrisitan,christian chrisitanity,christianity @@ -4158,6 +8135,7 @@ christinaity,christianity christinas,christians christines,christians christmans,christians +chrminance,chrominance chroline,chlorine chromasome,chromosome chromasomes,chromosomes @@ -4175,6 +8153,7 @@ chromosoom,chromosome chromossome,chromosomes chromozome,chromosome chromozomes,chromosomes +chromum,chromium chronciles,chronicles chronicales,chronicles chronicals,chronicles @@ -4194,17 +8173,39 @@ chruches,churches chtulhu,cthulhu chuch,church chuckels,chuckles +chuks,chunks +chunaks,chunks +chunck,chunk +chuncked,chunked +chuncking,chunking +chuncks,chunks +chuncksize,chunksize +chuncs,chunks +chuned,chunked churchers,churches churchs,churches +cick,click +cicrle,circle +cicruit,circuit +cicruits,circuits cicrulating,circulating +cicular,circular +ciculars,circulars cielings,ceilings cigarattes,cigarettes cigarete,cigarets cigaretts,cigarettes cigeratte,cigarette cigerattes,cigarettes +cihpher,cipher +cihphers,ciphers cilanto,cilantro -cilents,clients +cilent,client,silent +cilents,clients,silents,silence +cilincer,cylinder,silencer +cilincers,cylinders,silencers +cilinder,cylinder +cilinders,cylinders cilivians,civilians cilivization,civilizations cilmbers,climbers @@ -4212,6 +8213,9 @@ cilnatro,cilantro cilpboard,clipboard ciltoris,clitoris cilynders,cylinders +cilyndre,cylinder +cilyndres,cylinders +cilyndrs,cylinders cincinatti,cincinnati cincinnasti,cincinnati cincinnatti,cincinnati @@ -4224,8 +8228,31 @@ cinematograpy,cinematography cinematogrophy,cinematography cinematogrpahy,cinematography cinemetography,cinematography +cinfiguration,configuration +cinfigurations,configurations cinimatography,cinematography cinncinati,cincinnati +cintaner,container +ciontrol,control +ciper,cipher +cipers,ciphers +cipersuite,ciphersuite +cipersuites,ciphersuites +cipertext,ciphertext +cipertexts,ciphertexts +ciph,cipher,chip +ciphe,cipher +cipherntext,ciphertext +ciphersuit,ciphersuite +ciphersuits,ciphersuites +ciphersute,ciphersuite +ciphersutes,ciphersuites +cipheruite,ciphersuite +cipheruites,ciphersuites +ciphes,ciphers +ciphr,cipher +ciphrs,ciphers +cips,chips circels,circles circimcised,circumcised circiuts,circuits @@ -4234,8 +8261,13 @@ circlebs,circles circluar,circular circluating,circulating circomference,circumference +circomvent,circumvent +circomvented,circumvented +circomvents,circumvents +circual,circular circualtion,circulation circuis,circuits +circuitery,circuitry circuitos,circuits circulacion,circulation circulaire,circular @@ -4247,6 +8279,7 @@ circumcison,circumcision circumcission,circumcision circumcition,circumcision circumferance,circumference +circumferencial,circumferential circumsice,circumcised circumsiced,circumcised circumsicion,circumcision @@ -4257,6 +8290,7 @@ circumsision,circumcision circumsition,circumcision circumsizion,circumcision circumstace,circumstance +circumstancial,circumstantial circumstanes,circumstance circumstanial,circumstantial circumstansial,circumstantial @@ -4267,6 +8301,11 @@ circumstantional,circumstantial circumstantual,circumstantial circumstential,circumstantial circumstnaces,circumstance +circumstnce,circumstance +circumstnces,circumstances +circumstncial,circumstantial +circumstntial,circumstantial +circumvernt,circumvent circumvrent,circumvent circumwent,circumvent circuncised,circumcised @@ -4276,19 +8315,56 @@ circunstance,circumstance circunstances,circumstances circunstantial,circumstantial circunvent,circumvent +circustances,circumstances circut,circuit +circuts,circuits +ciricle,circle +ciricles,circles ciricuit,circuit +ciricuits,circuits +ciricular,circular +ciricularise,circularise +ciricularize,circularize ciriculum,curriculum +cirilic,cyrillic +cirillic,cyrillic +ciritc,critic +ciritcal,critical +ciritcality,criticality +ciritcals,criticals +ciritcs,critics +ciriteria,criteria +ciritic,critic +ciritical,critical +ciriticality,criticality +ciriticals,criticals +ciritics,critics cirlces,circles cirlcing,circling +cirle,circle +cirles,circles cirruculum,curriculum +cirsumstances,circumstances +cirtcuit,circuit cirticise,criticise cirticising,criticising +cirucal,circular +cirucit,circuit ciruclar,circular ciruclating,circulating ciruclation,circulation +ciruclator,circulator cirucmference,circumference +cirucmflex,circumflex cirucmstances,circumstances +cirucular,circular +cirucumstance,circumstance +cirucumstances,circumstances +ciruit,circuit +ciruits,circuits +cirumflex,circumflex +cirumstance,circumstance +cirumstances,circumstances citicenship,citizenship citisenship,citizenship citizinship,citizenship @@ -4303,9 +8379,19 @@ civilizatoin,civilizations civilizaton,civilization civilizatons,civilizations civillian,civilian +civillians,civilians civilziation,civilizations civizilation,civilizations +cjange,change +cjanged,changed +cjanges,changes +cjoice,choice +cjoices,choices +ckecksum,checksum +claaes,classes clacium,calcium +claculate,calculate +claculation,calculation claculations,calculations claculator,calculator claculators,calculators @@ -4314,24 +8400,41 @@ claerer,clearer claerly,clearly clagary,calgary claibre,calibre +claibscale,calibscale +claime,claim claimes,claims clairfy,clarify clairfying,clarifying clairty,clarity +clame,claim clanand,clannad clannand,clannad +claread,cleared +clared,cleared +clarety,clarity clarfiy,clarify clarificaiton,clarification clarifiy,clarify +claring,clearing clarskon,clarkson clas,class clasic,classic clasical,classical clasically,classically -clasification,clarification +clasification,clarification,classification +clasified,classified +clasifies,classifies +clasify,classify +clasifying,classifying +classe,class,classes +classess,classes +classesss,classes classicals,classics classicos,classics classicus,classics +classifed,classified +classifer,classifier +classifers,classifiers classificaiton,classification classificato,classification classifides,classified @@ -4339,31 +8442,67 @@ classifiy,classify classis,classics classrom,classroom classrooom,classroom +classs,class +classses,classes classsic,classics clasues,clauses +clatified,clarified +claus,clause clausens,clauses claymer,claymore claymoe,claymore +clcoksource,clocksource +clcosed,closed +clea,clean +cleaer,clear,clearer,cleaner +cleaered,cleared +cleaing,cleaning +cleancacne,cleancache +cleand,cleaned,cleans,clean cleanes,cleanse +cleaness,cleanness cleanies,cleanse cleanilness,cleanliness cleanisng,cleansing cleanleness,cleanliness cleanliess,cleanliness cleanlyness,cleanliness +cleanning,cleaning +cleannup,cleanup +cleanp,cleanup +cleanpu,cleanup +cleanpus,cleanups cleansiness,cleanliness +cleantup,cleanup +cleare,cleared,clear cleareance,clearance +clearified,clarified +clearifies,clarifies +clearify,clarify +clearifying,clarifying +clearling,clearing +clearnance,clearance +clearnances,clearances +clearted,cleared cleasne,cleanse cleasner,cleanser cleasning,cleansing +cleck,check +cleean,clean +cleff,clef +cleint,client cleints,clients clenase,cleanse clenaser,cleanser -clera,clear +cler,clear +clera,clear,sclera clerification,clarification +clese,close +cleses,closes clesius,celsius cletics,celtics clevelry,cleverly +clevely,cleverly cleverleys,cleverly clevery,cleverly clhorine,chlorine @@ -4372,25 +8511,38 @@ cliantro,cilantro clickare,clicker clickbat,clickbait clickear,clicker +cliens,clients +clienta,client +cliente,client,clientele +clientelle,clientele clientes,clients cliffbanger,cliffhanger cliffhager,cliffhanger cliffhander,cliffhanger cliffhangar,cliffhanger clifthanger,cliffhanger +clik,click clikcbait,clickbait +cliks,clicks climateers,climates climatiser,climates climats,climates climbes,climbers +climer,climber +climers,climbers +climing,climbing clincial,clinical clincially,clinically clincis,clinics +clinets,clients clinicaly,clinically clinicas,clinics clinicos,clinics clipbaord,clipboard clipboad,clipboard +clipoard,clipboard +clipoards,clipboards +clipoing,clipping clitiros,clitoris clitoridis,clitoris clitories,clitoris @@ -4398,19 +8550,141 @@ clitorios,clitoris clitorious,clitoris clitorius,clitoris clitors,clitoris +cliuent,client +cliuents,clients +clloud,cloud +cllouded,clouded +clloudes,clouds +cllouding,clouding +cllouds,clouds +cloack,cloak +cloacks,cloaks +cloberring,clobbering +clocksourc,clocksource +clockwíse,clockwise +clodes,closed,clothes +cloding,closing +cloes,close +cloesd,closed +cloesed,closed +cloesing,closing cloesly,closely +clonez,clones,cloner +clonning,cloning +clory,glory +clos,close closeing,closing closeley,closely +closests,closest,closets +closig,closing closley,closely +clossed,closed +clossing,closing +cloude,cloud +cloudes,clouds +clousre,closure +clsoe,close +cluase,clause cluases,clauses clucthing,clutching +clude,clued,clue +clumn,column +clumsly,clumsily cluprit,culprit +cluser,cluster +clusetr,cluster +clustred,clustered clutchign,clutching cluthcing,clutching clyamore,claymore clyinder,cylinder +cmak,cmake +cmmands,commands +cmobination,combination cmoputer,computer +cmoputers,computers +cna,can +cnannel,channel +cnfiguration,configuration +cnfigure,configure +cnfigured,configured +cnfigures,configures +cnfiguring,configuring +cnosole,console +cnosoles,consoles +cntain,contain +cntains,contains +cnter,center +coalace,coalesce +coalacece,coalesce,coalescence +coalaced,coalesced +coalacence,coalescence +coalacing,coalescing +coalaesce,coalesce +coalaesced,coalesced +coalaescence,coalescence +coalaescing,coalescing +coalascece,coalescence +coalascence,coalescence +coalase,coalesce +coalasece,coalescence +coalased,coalesced +coalasence,coalescence +coalases,coalesces +coalasing,coalescing +coalcece,coalescence +coalcence,coalescence +coalesc,coalesce +coalescsing,coalescing coalese,coalesce +coalesed,coalesced +coalesence,coalescence +coalessing,coalescing +coallate,collate +coallates,collates +coallating,collating +coallece,coalesce +coalleced,coalesced +coallecence,coalescence +coalleces,coalesces +coallecing,coalescing +coallee,coalesce +coalleed,coalesced +coalleence,coalescence +coallees,coalesces +coalleing,coalescing +coallesce,coalesce +coallesced,coalesced +coallesceing,coalescing +coallescence,coalescence +coallesces,coalesces +coallescing,coalescing +coallese,coalesce +coallesed,coalesced +coallesence,coalescence +coalleses,coalesces +coallesing,coalescing +coallesse,coalesce +coallessed,coalesced +coallessence,coalescence +coallesses,coalesces +coallessing,coalescing +coallision,collision +coallisions,collisions +coallition,coalition,collation +coalsce,coalesce +coalscece,coalescence +coalsced,coalesced +coalscence,coalescence +coalscing,coalescing +coalsece,coalescence +coalseced,coalesced +coalsecense,coalescence +coalsence,coalescence +coaslescing,coalescing +cobining,combining +cobvers,covers +coccinele,coccinelle cockaroches,cockroaches cockatils,cocktails cockraoches,cockroaches @@ -4421,16 +8695,88 @@ cockroahes,cockroaches cocktailers,cocktails cocktials,cocktails coctail,cocktail +cocument,document +cocumentation,documentation +cocuments,document +codde,code,coded,coddle +codeing,coding +codepoitn,codepoint +codesc,codecs +codespel,codespell +codesream,codestream +coditions,conditions +coduct,conduct +coducted,conducted +coducter,conductor +coducting,conducting +coductor,conductor +coducts,conducts +coeffcient,coefficient +coeffcients,coefficients coefficeint,coefficient +coefficeints,coefficients coefficent,coefficient +coefficents,coefficients coefficiant,coefficient coefficienct,coefficient +coeffiecient,coefficient +coeffiecients,coefficients +coeffient,coefficient +coeffients,coefficients +coeficent,coefficient +coeficents,coefficients +coeficient,coefficient +coeficients,coefficients +coelesce,coalesce coencidental,coincidental +coercable,coercible +coerceion,coercion +coersion,coercion +coexhist,coexist +coexhistance,coexistence +coexhisted,coexisted +coexhistence,coexistence +coexhisting,coexisting +coexhists,coexists +coexinst,coexist +coexinstence,coexistence +coexinsts,coexists +coexistance,coexistence +coexsit,coexist +coexsitance,coexistence +coexsited,coexisted +coexsitence,coexistence +coexsiting,coexisting +coexsits,coexists +cofeee,coffee +cofidence,confidence +cofiguration,configuration +cofigure,configure +cofigured,configured +cofigures,configures +cofiguring,configuring +cofirm,confirm +cofirmation,confirmation +cofirmations,confirmations +cofirmed,confirmed +cofirming,confirming +cofirms,confirms coform,conform +cofrim,confirm +cofrimation,confirmation +cofrimations,confirmations +cofrimed,confirmed +cofriming,confirming +cofrims,confirms cognatious,contagious cognitivie,cognitive cognizent,cognizant +coherance,coherence +coherancy,coherency +coherant,coherent +coherantly,coherently cohesie,cohesive +coice,choice coincedental,coincidental coincedentally,coincidentally coincedince,coincidence @@ -4445,15 +8791,34 @@ coincidince,coincidence coincidnce,coincide coindice,coincide coindidental,coincidental +coinitailize,coinitialize +coinside,coincide +coinsided,coincided coinsidence,coincidence +coinsident,coincident coinsidental,coincidental coinsidentally,coincidentally +coinsides,coincides +coinsiding,coinciding +cointain,contain +cointained,contained +cointaining,containing +cointains,contains cointerpoint,counterpoint +colaboration,collaboration colaborations,collaborations colateral,collateral +coldplg,coldplug +colected,collected +colection,collection +colelction,collection colelctive,collective colelctors,collectors +colerscheme,colorscheme +colescing,coalescing colgone,cologne +colision,collision +colission,collision collabarate,collaborate collabaration,collaboration collaberate,collaborate @@ -4467,14 +8832,18 @@ collaboratin,collaboration collaborato,collaboration collaboratore,collaborate collabore,collaborate +collaction,collection +collaobrative,collaborative collape,collapse collapes,collapse +collapsable,collapsible collapseing,collapsing collapsers,collapses collaquial,colloquial collares,collars collaris,collars collaros,collars +collasion,collision collaspe,collapse collasped,collapsed collaspes,collapses @@ -4482,11 +8851,15 @@ collasping,collapsing collataral,collateral collaterial,collateral collaterol,collateral +collationg,collation collatoral,collateral collcetion,collections colleage,colleagues colleauge,colleague colleauges,colleagues +collecing,collecting +collecion,collection +collecions,collections colleciton,collection collecte,collective collectems,collects @@ -4496,6 +8869,7 @@ collectief,collective collecties,collects collectieve,collective collectifs,collects +collectin,collection collectioners,collections collectivelly,collectively collectivily,collectively @@ -4508,37 +8882,56 @@ collecton,collection collectons,collections collectos,collectors collectros,collects +colleection,collection collegaue,colleague collegaues,colleagues collegue,colleague collegues,colleagues +collektion,collection collequial,colloquial collest,collects colleteral,collateral +colletion,collection colliquial,colloquial collisin,collisions -collission,collisions +collison,collision,collusion +collisons,collisions,collusion,collusions +collission,collisions,collision,collusion collisson,collisions collitions,collisions +colllapses,collapses collobarate,collaborate collobaration,collaboration colloborate,collaborate +collocalized,colocalized collonade,colonnade collonies,colonies collony,colony colloqiual,colloquial colloquail,colloquial colloqueal,colloquial +collorscheme,colorscheme collosal,colossal collpase,collapse collpased,collapsed collpases,collapses collpasing,collapsing +collsions,collisions collumn,column +collumns,columns +colmn,column +colmns,columns +colmuned,columned coloardo,colorado +coloer,color +coloeration,coloration +coloered,colored +coloering,coloring +coloers,colors cologen,cologne colomba,colombia colombina,colombia +colomns,columns colonge,cologne colonialisim,colonialism colonializm,colonialism @@ -4552,60 +8945,117 @@ colonozation,colonization colorao,colorado colorblend,colorblind colordao,colorado +colorfull,colorful,colorfully +coloringh,coloring +colorizoer,colorizer +colorpsace,colorspace +colorpsaces,colorspaces +colose,close coloublind,colorblind +coloum,column +coloumn,column +coloumns,columns +coloums,columns colourd,coloured +colourfull,colourful,colourfully +colourpsace,colourspace +colourpsaces,colourspaces +colsed,closed colubmia,columbia +colum,column columbidae,columbia columbina,columbia +colummn,column +colummns,columns columnas,columns +columnular,columnar +colums,columns columsn,columns +colunn,column,colon +colunns,columns comadres,comrades -comander,commander +comammand,command +comamnd,command +comamnded,commanded +comamnding,commanding +comamndline,commandline +comamnds,commands +comand,command +comander,commander,commandeer comando,commando comandos,commandos comany,company comapany,company +comapared,compared +comapatibility,compatibility +comapatible,compatible +comapletion,completion comapnies,companies comapnions,companions comapny,company comaprable,comparable comapre,compare comapres,compares +comapring,comparing comaprison,comparison comaprisons,comparisons comaptible,compatible +comarators,comparators comarde,comrade comback,comeback +combained,combined combanations,combinations combatabts,combatants combatans,combatants combatents,combatants combatibility,compatibility -combiantion,combinations +combatible,compatible +combiantion,combinations,combination +combiation,combination +combiations,combinations combiens,combines combinacion,combination combinaison,combinations combinaiton,combinations +combinate,combine +combinateion,combination +combinateions,combinations combinatin,combinations combinatino,combinations combinatins,combinations +combinatio,combination combinatios,combinations combinato,combination combinaton,combination +combinatorical,combinatorial +combinbe,combined +combind,combined +combinded,combined combinig,combining +combinine,combine combinining,combining combins,combines combonation,combination combonations,combinations combusion,combustion +comceptually,conceptually comdeic,comedic comdemnation,condemnation +comect,connect +comected,connected +comecting,connecting +comectivity,connectivity comediac,comedic comediantes,comedians comediants,comedians comedias,comedians +comedlib,comedilib comemmorates,commemorates comemoretion,commemoration +coment,comment +comented,commented +comenting,commenting +coments,comments comepndium,compendium comeptition,competition comeptitions,competitions @@ -4614,10 +9064,14 @@ comeptitively,competitively comeptitors,competitors comestic,cosmetic comestics,cosmetics +cometed,commented,competed comfertable,comfortable comfertably,comfortably comferting,comforting +comfirm,confirm comfirmation,confirmation +comflicting,conflicting +comformance,conformance comforming,comforting comfortabel,comfortably comfortabil,comfortably @@ -4631,6 +9085,9 @@ comfrontational,confrontational comfrotable,comfortable comftorable,comfortable comftorably,comfortably +comiled,compiled +comilers,compilers +comination,combination comision,commission comisioned,commissioned comisioner,commissioner @@ -4641,11 +9098,39 @@ comissioned,commissioned comissioner,commissioner comissioning,commissioning comissions,commissions +comit,commit comited,committed +comitee,committee comiting,committing +comits,commits +comitte,committed,committee comitted,committed comittee,committee +comittees,committees +comitter,committer comitting,committing +comittish,committish +comlain,complain +comlained,complained +comlainer,complainer +comlaining,complaining +comlains,complains +comlaint,complaint +comlaints,complaints +comlete,complete +comleted,completed +comletely,completely +comletion,completion +comletly,completely +comlex,complex +comlexity,complexity +comlpeter,completer +commad,command +commadn,command +commadnline,commandline +commadns,commands +commads,commands +comman,command,common commandbox,commando commandd,commanded commandemnts,commandment @@ -4653,26 +9138,44 @@ commandent,commandment commandered,commanded commandes,commands commandeur,commanders +commandi,command commandmant,commandment commandmants,commandments commandmends,commandments +commandoes,commandos commandore,commanders commandpod,commando commanists,communists +commannd,command commano,commando commans,commands +commansd,commands +commant,command,comment commantator,commentator +commanted,commanded,commented +commants,commands,comments +commatas,commas,commata commecen,commence +commect,connect +commected,connected +commecting,connecting +commectivity,connectivity commedic,comedic commemerative,commemorative commemmorate,commemorate commemmorating,commemorating commemters,commenters +commen,commend,comment,common commencera,commerce commenciez,commence commendment,commandment commendments,commandments +commenet,comment +commenetd,commented +commeneted,commented +commens,comments,commons commense,commenters +commenstatus,commentstatus commentaar,commentary commentar,commentator commentare,commenter @@ -4701,20 +9204,25 @@ commericals,commercials commericial,commercial commericially,commercially commerorative,commemorative +commeted,commented,competed commiest,commits +commig,commit,coming comming,coming comminicate,communicate comminicated,communicated comminication,communication comminists,communists +comminity,community comminucate,communicate -comminucation,communications +comminucating,communicating +comminucation,communications,communication commishioned,commissioned commishioner,commissioner commision,commission commisioned,commissioned commisioner,commissioner commisioning,commissioning +commisions,commissions commisison,commissions commissionar,commissioner commissionees,commissions @@ -4723,38 +9231,138 @@ commissionner,commissioner commissionor,commissioner commissons,commissions commisssion,commissions +commitable,committable commitd,committed commited,committed commitee,committee commiteed,committed +commiter,committer +commiters,committers commites,commits commiteted,committed +commiti,committee,committing,commit +commitin,committing commiting,committing +commitish,committish commitmet,commitments +committ,commit committe,committee +committi,committee +committis,committees committment,commitment committments,commitments committs,commits +committy,committee commitus,commits +commma,comma commmand,command +commmandline,commandline +commmands,commands commmemorated,commemorated +commment,comment +commmented,commented +commmenting,commenting +commments,comments +commmet,comment +commmets,comments +commmit,commit +commmited,committed +commmiting,committing +commmits,commits +commmitted,committed +commmitter,committer +commmitters,committers +commmitting,committing +commmon,common +commmunicate,communicate +commmunicated,communicated +commmunicates,communicates +commmunicating,communicating +commmunication,communication +commmunity,community +commna,comma +commnad,command +commnadline,commandline +commnads,commands +commnand,command +commnandline,commandline +commnands,commands +commnd,command +commndline,commandline +commnds,commands +commnent,comment +commnents,comments +commnetary,commentary +commnication,communication +commnt,comment +commnted,commented +commnuative,commutative +commnunicating,communicating +commnunication,communication +commnunity,community commodites,commodities commoditites,commodities +commoditiy,commodity commodoties,commodities +commom,common commomplace,commonplace commomwealth,commonwealth +commond,command commongly,commonly commonhealth,commonwealth commonspace,commonplace +commont,common,comment +commontly,commonly commonweath,commonwealth commonweatlh,commonwealth commonwelath,commonwealth commonwelth,commonwealth +commpact,compact +commpaction,compaction +commpand,command,compand +commpare,compare +commparisons,comparisons +commpatibility,compatibility +commpatible,compatible +commpessed,compressed +commpilation,compilation +commpile,compile +commpiled,compiled +commpiling,compiling +commplain,complain +commplete,complete +commpleted,completed +commpletely,completely +commpletes,completes +commpletion,completion +commplex,complex +commpliant,compliant +commplied,complied +commpn,common +commponent,component +commponents,components +commpound,compound +commpresd,compressed +commpresed,compressed +commpresion,compression +commpress,compress +commpressd,compressed +commpressed,compressed +commpression,compression +commpute,compute +commputed,computed +commputer,computer +commputes,computes +commputing,computing commtiment,commitments +commtited,committed +commtted,committed +commuication,communication commuications,communications commuincate,communicated commuincation,communications commuinications,communications +communcation,communication communciate,communicate communciated,communicated communciation,communication @@ -4762,8 +9370,9 @@ communciations,communications communiaction,communications communiation,communication communicae,communicated +communicaion,communication communicaiton,communication -communicatie,communicate +communicatie,communicate,communication communicatin,communications communicatoin,communications communicaton,communication @@ -4779,14 +9388,42 @@ communite,communities communites,communities communitites,communities communits,communist +communiy,community +communiyt,community communsim,communism communters,commenters +communuication,communication +commutated,commuted +commutating,commuting +commutive,commutative +comnmand,command +comnnected,connected +comnparing,comparing +comnpletion,completion +comnpresion,compression +comnpress,compress +comon,common +comonent,component +comor,color compability,compatibility +compabillity,compatibility +compabitility,compatibility compadibility,compatibility compadible,compatible +compagnion,companion compagnons,companions +compagny,company +compaibility,compatibility +compain,complain compaines,companies compainons,companions +compair,compare +compaire,compare +compaired,compared +compairing,comparing +compairison,comparison +compairisons,comparisons +compairs,compares compairson,comparison compalation,compilation compalined,complained @@ -4798,36 +9435,88 @@ companines,companions companis,companions compansate,compensate compansated,compensated +compansates,compensates compansating,compensating compansation,compensation +compansations,compensations comparabil,comparable comparabile,comparable +comparaison,comparison +comparare,compare comparasion,comparison comparason,comparison comparasons,comparisons comparaste,compares +comparater,comparator comparatie,comparative +comparation,comparison +comparations,comparisons comparativley,comparatively comparativly,comparatively +compareable,comparable compareble,comparable +compareison,comparison +compareisons,comparisons comparement,compartment comparemos,compares comparetive,comparative comparetively,comparatively -comparions,comparison +compariable,comparable +comparied,compared +comparign,comparing +comparigon,comparison +comparigons,comparisons +compariing,comparing +comparion,comparison +comparions,comparison,comparisons +comparios,comparison compariosn,comparisons +comparioss,comparisons +comparisaion,comparison +comparisaions,comparisons +comparisation,comparison +comparisations,comparisons +comparisement,comparison +comparisements,comparisons comparisen,compares +comparisin,comparison +comparising,comparing +comparisins,comparisons comparision,comparison comparisions,comparisons -comparisn,comparisons -comparission,comparisons -comparisson,comparisons +comparism,comparison +comparisment,comparison +comparisments,comparisons +comparisms,comparisons +comparisn,comparisons,comparison +comparisns,comparisons +comparispon,comparison +comparispons,comparisons +comparission,comparisons,comparison +comparissions,comparisons +comparisson,comparisons,comparison comparissons,comparisons +comparistion,comparison +comparistions,comparisons +compariston,comparison +comparistons,comparisons comparitave,comparative comparitavely,comparatively +comparition,comparison +comparitions,comparisons +comparititive,comparative +comparititively,comparatively comparitive,comparative comparitively,comparatively +comparitor,comparator +comparitors,comparators comparitve,comparative +comparizon,comparison +comparizons,comparisons +comparment,compartment +comparotor,comparator +comparotors,comparators +comparre,compare comparse,compares comparsion,comparison comparsions,comparisons @@ -4838,13 +9527,35 @@ compase,compares compassione,compassionate compasso,compassion compasssion,compassion +compatabable,compatible +compatabiity,compatibility compatabile,compatible compatabilities,compatibilities compatability,compatibility +compatabillity,compatibility +compatabilty,compatibility +compatabily,compatibility +compatable,compatible +compatablie,compatible,compatibly +compatablility,compatibility compatablities,compatibilities +compatablitiy,compatibility compatablity,compatibility +compatably,compatibly +compataibility,compatibility +compataible,compatible +compataility,compatibility +compatatbility,compatibility +compatatble,compatible +compatatible,compatible compatative,comparative +compatator,comparator +compatators,comparators +compatbile,compatible +compatbility,compatibility +compatiability,compatibility compatiable,compatible +compatiablity,compatibility compatibel,compatible compatibil,compatible compatibile,compatible @@ -4853,8 +9564,14 @@ compatibillity,compatibility compatibiltiy,compatibility compatibilty,compatibility compatibily,compatibility +compatibity,compatibility +compatiblilty,compatibility compatiblities,compatibilities compatiblity,compatibility +compation,compaction +compatitbility,compatibility +compativle,compatible +compaytibility,compatibility compeating,completing compede,competed compeditive,competitive @@ -4866,13 +9583,17 @@ compeeting,completing compeitions,competitions compeittion,competitions compelation,compilation +compeletely,completely compelte,complete compeltely,completely +compeltelyt,completely compeltes,completes compelting,completing compeltion,completion +compeltly,completely compemdium,compendium compenduim,compendium +compenent,component,competent compenents,components compenidum,compendium compensacion,compensation @@ -4907,10 +9628,12 @@ competenze,competence competeted,competed competetion,competition competetions,competitions +competetive,competitive competetor,competitor competetors,competitors competidor,competitor -competion,competition +competion,competition,completion +competions,completions competiors,competitors competitavely,competitively competiters,competitors @@ -4935,7 +9658,14 @@ competitve,competitive competive,competitive competiveness,competitiveness competution,computation +compex,complex +compfortable,comfortable comphrehensive,comprehensive +compiant,compliant +compicated,complicated +compications,complications +compied,compiled +compilability,compatibility compilacion,compilation compilance,compliance compilant,compliant @@ -4944,6 +9674,10 @@ compilato,compilation compilaton,compilation compilcated,complicate compilcations,complication +compiliant,compliant +compiliation,compilation +compilier,compiler +compiliers,compilers compilr,compiler compination,compilation compinsate,compensate @@ -4956,6 +9690,7 @@ compitance,compliance compitation,computation compitent,competent compitetion,competitions +compitible,compatible complacant,complacent complacient,complacent complaince,compliance @@ -4967,34 +9702,63 @@ complainig,complaining complainte,complained complais,complains complane,complacent -complate,complacent -complation,completion +complanied,complained +complate,complacent,complete +complated,completed +complates,completes +complating,completing +complation,completion,compilation +complatly,completely +complatness,completeness +complats,completes complciated,complicate complciations,complication +compleate,complete +compleated,completed +compleates,completes +compleating,completing compleation,compilation compleatly,completely complecate,complicate complecated,complicated complecations,complications compleet,complete +compleete,complete +compleeted,completed +compleetly,completely +compleetness,completeness +complelely,completely +complelte,complete +complementt,complement +compleness,completeness +complession,compression +complet,complete completaste,completes completeds,completes completeing,completing completeion,completion completelly,completely +completelty,completely completelyl,completely completelys,completes completen,complement completenes,completes completent,complement completetion,completion +completetly,completely completey,completely completi,complexity completily,complexity completin,completion +completiom,completion +completition,completion completito,completion completley,completely +completly,completely +completness,completeness complets,completes +complette,complete +complettly,completely complety,completely complexers,complexes complexety,complexity @@ -5002,10 +9766,13 @@ complexitiy,complexity complexs,complexes complext,complexity complexy,complexity +compliace,compliance compliacted,complicate compliactions,complication +compliancy,compliance complianed,compliance complians,complains +complianse,compliance compliants,complaints compliation,compilation compliations,compilation @@ -5028,9 +9795,15 @@ complict,complicit complictaed,complicate complicted,complicated complience,compliance +complient,compliant complier,compiler +compliers,compilers complilation,complication complilations,complications +complile,compile +compliled,compiled +compliles,compiles +compliling,compiling complimate,complicate complimation,complication complimenary,complimentary @@ -5043,33 +9816,58 @@ complimentory,complimentary complimentry,complimentary complimenty,complimentary complination,complication +compling,compiling complitation,complication complition,completion +complmenet,complement +complted,completed complusion,compulsion complusions,compulsion complusive,compulsive complusory,compulsory +compluter,computer compnay,company +compnent,component +compnents,components +compoennt,component +compoent,component +compoents,components +compoesd,composed compolation,compilation compolsive,compulsive compolsory,compulsory compolsury,compulsory +compoment,component +compoments,components componant,component componants,components +componbents,components +componding,compounding +componemt,component +componemts,components componenet,components componenets,components +componens,components componentes,components compones,compose -componet,components +componet,components,component +componets,components +componnents,components componsate,compensate +componsites,composites +compontent,component +compontents,components componts,compost comporable,comparable +composablity,composability composet,compost +composibility,composability +composiblity,composability composicion,composition composiiton,compositions composision,compositions composistion,compositions -composit,compost +composit,compost,composite compositie,composite compositied,composite composities,composite @@ -5082,6 +9880,8 @@ composte,compose compostiion,compositions compotition,composition compots,compost +compount,compound +comppatible,compatible comprable,comparable compraison,comparisons compramise,compromise @@ -5089,19 +9889,27 @@ compramised,compromised compramises,compromises compramising,compromising comprassem,compress +compre,compare,compère +compredded,compressed comprehand,comprehend comprehention,comprehension compremised,compromised compremises,compromises compremising,compromising comprension,compression +compres,compress,compares compresas,compress comprese,compressed -compreses,compress +compresed,compressed +compreser,compressor +compreses,compress,compresses +compresing,compressing compresion,compression compreso,compressor +compresor,compressor compresores,compressor compresors,compressor +compressable,compressible compresser,compressor compressio,compressor compresson,compression @@ -5125,13 +9933,20 @@ compromizing,compromising compromosing,compromising compromsie,compromises comprossor,compressor +compsable,composable compsers,compress -comptability,compatibility +compsite,composite +comptabile,compatible +comptability,compatibility,computability compteting,completing comptetion,completion compteurs,computers +comptible,compatible comptown,compton +comptue,compute comptuers,computers +compuatation,computation +compuation,computation compulisve,compulsive compulosry,compulsory compulsary,compulsory @@ -5143,6 +9958,8 @@ compulsorary,compulsory compulstion,compulsion compulsury,compulsory compunation,computation +compund,compound +compunds,compounds compunet,compute compuslion,compulsion compuslive,compulsive @@ -5150,35 +9967,100 @@ compuslory,compulsory compustion,compulsion computacion,computation computacional,computational +computaion,computation computanti,computation computarized,computerized computating,computation computationnal,computational computato,computation +computaton,computation computition,computation computre,compute +computtaion,computation +computtaions,computations comradets,comrades comradre,comrade comrads,comrades +comress,compress +comressed,compressed +comression,compression comrpomising,compromising comsetic,cosmetic comsetics,cosmetics +comstraint,constraint +comsume,consume +comsumed,consumed +comsumer,consumer +comsumers,consumers +comsumes,consumes +comsuming,consuming +comsumption,consumption +comtain,contain +comtained,contained +comtainer,container +comtains,contains comtaminated,contaminated comtamination,contamination comtemplating,contemplating comtemporary,contemporary comtpon,compton +comunicate,communicate +comunication,communication +comunity,community +comute,commute,compute +comuted,commuted,computed +comventions,conventions +comverted,converted +conain,contain +conained,contained +conainer,container +conainers,containers +conaines,contains +conaining,containing +conains,contains +conaint,contain +conainted,contained +conainter,container conanical,canonical +conatain,contain +conatainer,container +conatainers,containers +conatains,contains +conatin,contain +conatined,contained conatiner,container conatiners,containers +conatining,containing conatins,contains +conbination,combination conbinations,combinations -concatinated,contaminated -concatination,contamination +conbtrols,controls +concaneted,concatenated +concantenated,concatenated +concatenaded,concatenated +concatenaion,concatenation +concatened,concatenated +concatentaion,concatenation +concatentate,concatenate +concatentated,concatenated +concatentates,concatenates +concatentating,concatenating +concatentation,concatenation +concatentations,concatenations +concatented,concatenated +concatinated,contaminated,concatenated +concatination,contamination,concatenation +concatinations,concatenations +concating,concatenating +concatonate,concatenate +concatonated,concatenated +concatonates,concatenates +concatonating,concatenating conceald,concealed concedendo,conceded concedered,conceded conceed,concede +conceedd,conceded conceide,conceived conceitual,conceptual conceivablely,conceivably @@ -5193,9 +10075,15 @@ concencrate,concentrate concencration,concentration concened,concede concenrtation,concentrations +concensors,consensus concensus,consensus concentartion,concentrations concentate,concentrate +concentated,concentrated +concentates,concentrates +concentating,concentrating +concentation,concentration +concentic,concentric concenting,connecting concentrace,concentrate concentracion,concentration @@ -5213,6 +10101,7 @@ concentratie,concentrate concentratin,concentration concentrato,concentration concentratons,concentrations +concentraze,concentrate conceps,concepts concepta,conceptual conceptial,conceptual @@ -5221,9 +10110,12 @@ conceptuel,conceptual conceptul,conceptual concequences,consequences concequently,consequently -concered,concede +concered,concede,concerned +concerened,concerned +concering,concerning concernig,concerning concernt,concert +concerntrating,concentrating concersation,conservation concersion,concession concertas,concerts @@ -5241,6 +10133,7 @@ conceviable,conceivable conceviably,conceivably concevied,conceived concibes,concise +concicely,concisely concider,consider conciderable,considerable conciderably,considerably @@ -5251,6 +10144,7 @@ concidering,considering conciders,considers concides,concise concieted,conceited +concieve,conceive concieved,conceived concious,conscious conciously,consciously @@ -5286,6 +10180,11 @@ concsiousness,consciousness conculsion,conclusion conculsions,conclusions conculsive,conclusive +concurence,concurrence +concurency,concurrency +concurent,concurrent +concurently,concurrently +concurents,concurrents,concurrence concurment,concurrent concurrant,concurrent concurrect,concurrent @@ -5298,6 +10197,7 @@ condamned,condemned condamning,condemning condascending,condescending condeferacy,confederacy +condem,condemn condemantion,condemnation condemend,condemned condemmed,condemned @@ -5319,25 +10219,46 @@ condescensing,condescension condesend,condensed condesned,condensed condicional,conditional +condict,conduct +condicted,conducted +condident,confident +condidential,confidential +condidional,conditional condidtion,condition +condidtioning,conditioning condidtions,conditions +condifurable,configurable +condifuration,configuration +condifure,configure +condifured,configured +condig,config +condigdialog,configdialog +condiiton,condition +condionally,conditionally condiscending,condescending conditinal,conditional conditiner,conditioner +conditionaly,conditionally conditionar,conditioner conditiond,conditioned conditionel,conditional conditiong,conditioning +conditionn,condition conditionnal,conditional +conditionnaly,conditionally conditionned,conditioned conditionner,conditioner conditionning,conditioning +conditoinal,conditional conditon,condition +conditonal,conditional +conditons,conditions condiut,conduit condmen,condemn condmenation,condemnation condmened,condemned condmening,condemning +condntional,conditional condolances,condolences condolencies,condolences condolensces,condolences @@ -5351,23 +10272,116 @@ condradicting,contradicting condradiction,contradiction condradictions,contradictions condradictory,contradictory +condtiion,condition +condtiions,conditions +condtion,condition +condtional,conditional +condtionally,conditionally +condtionals,conditionals +condtioned,conditioned +condtions,conditions +condtition,condition +condtitional,conditional +condtitionals,conditionals +condtitions,conditions conductiong,conducting +conductuve,conductive,conducive conduict,conduit conduiting,conducting condulences,condolences +conecct,connect +coneccted,connected +coneccting,connecting +conecction,connection +conecctions,connections +conecctivities,connectivities +conecctivity,connectivity +conecctor,connector +conecctors,connectors +coneccts,connects +conecept,concept +conecepts,concepts +conecjture,conjecture +conecjtures,conjectures +conecnt,connect,content +conecntrate,concentrate +conecntrated,concentrated +conecntrates,concentrates conecntration,concentrations +conecnts,connects,contents +conecpt,concept +conecpts,concepts +conect,connect conected,connected +conecting,connecting conection,connection +conections,connections +conectivities,connectivities +conectivity,connectivity +conectix,connectix +conector,connector +conectors,connectors +conects,connects +conecurrency,concurrency +conecutive,consecutive +coneect,connect +coneected,connected +coneecting,connecting +coneection,connection +coneections,connections +coneectivities,connectivities +coneectivity,connectivity +coneector,connector +coneectors,connectors +coneects,connects +conenct,connect +conencted,connected conencting,connecting conenction,connection conenctions,connections +conenctivities,connectivities conenctivity,connectivity conenctor,connector conenctors,connectors conenctration,concentrations conencts,connects +conenience,convenience +conenient,convenient +coneninece,convenience +coneninet,convenient +conent,content +conents,contents +coner,corner,coroner +conergence,convergence +conern,concern +conerning,concerning +coners,corners,coroners +conersion,conversion +conersions,conversions +conert,convert +conerted,converted +conerter,converter +conerters,converters +conerting,converting +conervative,conservative conescutive,consecutive conesencus,consensus +conet,connect +coneted,connected +coneting,connecting +conetion,connection +conetions,connections +conetivities,connectivities +conetivity,connectivity +conetnt,content +conetor,connector +conetors,connectors +conets,connects +conetxt,context,connect +conetxts,contexts,connects +conexant,connexant +conext,context,connect,connects +conexts,contexts,connects confedaracy,confederacy confedarate,confederate confedarcy,confederacy @@ -5386,7 +10400,9 @@ confererate,confederate confermation,confirmation conferming,confirming confernece,conferences +conferrencing,conferencing confersation,conservation +confert,convert confescated,confiscated confeses,confess confesos,confess @@ -5395,13 +10411,30 @@ confessino,confessions confessionis,confessions confesso,confession confesssion,confessions +confety,confetti +conffiguration,configuration +confgiuration,configuration +confgiure,configure +confgiured,configured +confguration,configuration +confgure,configure +confgured,configured +confict,conflict +conficted,conflicted +conficts,conflicts confidance,confidence +confidantal,confidential +confidantally,confidentially +confidantals,confidentials +confidantial,confidential +confidantially,confidentially confidantly,confidently confidencial,confidential confidenciality,confidential confidenly,confidently confidense,confidence confidentail,confidential +confidental,confidential confidentally,confidentially confidentaly,confidently confidentely,confidently @@ -5410,42 +10443,106 @@ confidentuality,confidential confidenty,confidently confideny,confidently confids,confides -configruation,configurations +confifurable,configurable +confifuration,configuration +confifure,configure +confifured,configured +configaration,configuration +configed,configured +configer,configure +configiration,configuration +configire,configure +configiuration,configuration +configration,configuration +configrations,configurations +configred,configured +configruated,configured,configuration +configruation,configurations,configuration +configruations,configurations +configrued,configured +configuaration,configuration +configuarble,configurable +configuare,configure +configuared,configured +configuarion,configuration +configuarions,configurations configuartion,configuration configuartions,configurations +configuation,configuration +configuations,configurations configue,configure +configued,configured +configuerd,configured +configues,configures configuracion,configuration +configuraion,configuration configuraiton,configuration configurare,configure configurate,configure -configuratin,configurations +configuratiens,configurations +configuratin,configurations,configuration,configurating +configuratiom,configuration +configurationn,configuration +configuratioon,configuration configurato,configuration -configuratoin,configurations +configuratoin,configurations,configuration +configuratoins,configurations configuraton,configuration +configuratons,configurations +configuratrions,configurations +configuratuion,configuration configureable,configurable +configureing,configuring +configuretion,configuration +configurres,configures +configurring,configuring +configurses,configures +configurtation,configuration +configurting,configuring +configurtion,configuration +configury,configurable +configutation,configuration +configutations,configurations +configutration,configuration confilct,conflict confilcting,conflicting confilcts,conflicts confimred,confirmed confins,confines +confiramtion,confirmation confirmacion,confirmation +confirmaed,confirmed confirmas,confirms +confirmatino,confirmation +confirmatinon,confirmation confirmd,confirmed +confirmedd,confirmed +confirmeed,confirmed +confirmming,confirming confise,confines confisgated,confiscated +confiug,config +confiugure,configure conflcit,conflict conflciting,conflicting conflcits,conflicts conflcting,conflating conflicing,conflicting conflics,conflicts +conflictd,conflicts,conflicted +conflictin,conflicting conflictos,conflicts +conflift,conflict conflit,conflict confliting,conflating +confoguration,configuration +confort,comfort confortable,comfortable confrentation,confrontation confrentational,confrontational +confrim,confirm confrimation,confirmation +confrimations,confirmations confrimed,confirmed confriming,confirming confrims,confirms @@ -5455,11 +10552,67 @@ confrontaion,confrontation confrontating,confrontation confrontativo,confrontation confrontato,confrontation +confucing,confusing +confucion,confusion +confuction,conjunction +confudion,confusion +confue,confuse +confued,confused +confues,confuses +confugiration,configuration +confugirble,configurable +confugire,configure +confugired,configured +confugires,configures +confugiring,configuring +confugrable,configurable +confugration,configuration +confugre,configure +confugred,configured +confugres,configures +confugring,configuring +confugurable,configurable +confuguration,configuration confugurations,configurations +confugure,configure +confugured,configured +confugures,configures +confuguring,configuring +confuing,confusing +confunction,conjunction +confunder,confounder +confunse,confuse +confunsed,confused +confunses,confuses +confunsing,confusing +confurable,configurable +confuration,configuration +confure,configure +confured,configured +confures,configures +confuring,configuring +confurse,confuse +confursed,confused +confurses,confuses +confursing,confusing confussion,confession confussions,confessions +confusting,confusing +confuze,confuse +confuzed,confused +confuzes,confuses +confuzing,confusing +confuzze,confuse +confuzzed,confused +confuzzes,confuses +confuzzing,confusing congegration,congregation congergation,congregation +congifurable,configurable +congifuration,configuration +congifure,configure +congifured,configured +congigure,configure congitive,cognitive conglaturation,congratulations conglaturations,congratulations @@ -5489,55 +10642,133 @@ conicide,coincide conicidence,coincidence conicidental,coincidental conicidentally,coincidentally -conifguration,configurations +conider,consider +conifguration,configurations,configuration conifgurations,configurations +conifiguration,configuration +conig,config +conincide,coincide +conincidence,coincidence +conincident,coincident +conincides,coincides +coninciding,coinciding +coninient,convenient +coninstallable,coinstallable +coninuation,continuation +coninue,continue +coninues,continues +coninuity,continuity +coninuous,continuous conisderation,considerations +conitinue,continue conived,connived conjecutre,conjecture conjonction,conjunction +conjonctive,conjunctive conjucntion,conjunction conjuction,conjunction +conjuctions,conjunctions conjuncion,conjunction conjuncting,conjunction +conjuntion,conjunction +conjuntions,conjunctions conlcude,conclude conlcuded,concluded +conlcudes,concludes +conlcuding,concluding conlcusion,conclusion conlcusions,conclusions +conly,only +conmnection,connection +conmpress,compress +conmpression,compression +connaect,connect connatation,connotation connatations,connotations -conncetion,connections +conncection,connection +conncetion,connections,connection +connction,connection +conncurrent,concurrent +connecetd,connected +connecion,connection +connecions,connections connecitcut,connecticut conneciton,connection +connecitons,connections +connecor,connector +connecotr,connector connecs,connects +connecstatus,connectstatus +connectd,connected +connecte,connected connectes,connects +connectet,connected +connectibity,connectivity connecticon,connection connecticuit,connecticut connecticunts,connecticut connecties,connects +connectino,connection +connectinos,connections connectins,connects +connectiom,connection +connectioms,connections +connectiona,connection +connectionas,connections connectiong,connecting connectit,connecticut connectivety,connectivity connectivitiy,connectivity connectivty,connectivity connectivy,connectivity +connecto,connect +connecton,connection,connector connectos,connectors connectpro,connector +connectted,connected +connecttion,connection +conneection,connection +conneiction,connection +connektors,connectors connetation,connotation connetations,connotations +connetced,connected +connetcion,connection conneticut,connecticut +connetion,connection +connetor,connector connitations,connotations +connnect,connect +connnected,connected +connnecting,connecting +connnection,connection +connnections,connections +connnects,connects connonation,connotation connonations,connotations +connot,cannot connotacion,connotation connotaion,connotation +connstrain,constrain +connstrained,constrained +connstraint,constraint +conntents,contents +conntroller,controller conolization,colonization conontation,connotation +conosuer,connoisseur +conotation,connotation conotations,connotations +conpares,compares conpassionate,compassionate conpensating,compensating conpensation,compensation conpetitions,competitions +conplete,complete +conpleted,completed +conpletes,completes +conpleting,completing +conpletion,completion conplications,complications conplimentary,complimentary conplimented,complimented @@ -5556,7 +10787,22 @@ conquerring,conquering conquoring,conquering conqure,conquer conqured,conquered +conrete,concrete +conrol,control +conroller,controller +conrrol,control +conrrupt,corrupt +conrruptable,corruptible +conrrupted,corrupted +conrruptible,corruptible +conrruption,corruption +conrruptions,corruptions +conrrupts,corrupts +conrtib,contrib +conrtibs,contribs +consants,constants conscent,consent +consciencious,conscientious consciense,conscience consciouly,consciously consciouness,consciousness @@ -5566,12 +10812,22 @@ consdider,consider consdidered,considered consdieration,considerations consdiered,considered +consdired,considered +conseat,conceit +conseated,conceited +consective,consecutive +consectively,consecutively consectuive,consecutive consectutive,consecutive consecuence,consequence consecuences,consequences consecuentes,consequences consecuently,consequently +consecuitively,consecutively +conseed,concede +conseedd,conceded +conseeded,conceded +conseeds,concedes conseguence,consequence conselation,consolation consending,consenting @@ -5587,6 +10843,7 @@ consentration,concentration consentrations,concentrations consenusal,consensual consept,concept +consepts,concepts conseqeunces,consequence consequece,consequence consequencies,consequence @@ -5599,17 +10856,21 @@ consequentely,consequently consequentually,consequently consequenty,consequently consequeseces,consequences +consequetive,consecutive consequnce,consequence consequneces,consequence consequtive,consecutive +consequtively,consecutively consern,concern conserned,concerned +conserning,concerning conservacion,conservation conservanti,conservation conservare,conserve conservatie,conservatives conservaties,conservatives conservatisim,conservatism +conservativeky,conservatively conservativo,conservation conservativs,conservatism conservativsm,conservatism @@ -5622,11 +10883,17 @@ conservite,conserve conservitism,conservatism conservitive,conservative conservitives,conservatives +consestently,consistently +consevible,conceivable consficated,confiscated consicence,conscience consiciousness,consciousness consicous,conscious consicousness,consciousness +considder,consider +considderation,consideration +considdered,considered +considdering,considering considerabe,considerate considerabely,considerable considerabile,considerable @@ -5647,13 +10914,21 @@ consideratoin,considerations considerble,considerable considerbly,considerably considerd,considered +considere,consider,considered considereis,considers +consideren,considered +consideres,considered,considers consideret,considerate consideribly,considerably considerstion,considerations considerstions,considerations -considert,considerate +considert,considerate,considered,consider considertaion,considerations +considred,considered +consier,consider +consiers,considers +consifer,consider +consifered,considered consilation,consolation consilidate,consolidate consilidated,consolidated @@ -5661,27 +10936,60 @@ consious,conscious consipracies,conspiracies consipracy,conspiracy consiquently,consequently +consire,conspire,consider +consired,conspired,considered +consisant,consistent consisent,consistent +consisently,consistently +consisntency,consistency consistance,consistency +consistancy,consistency consistant,consistent consistantly,consistently +consisten,consistent consistencey,consistency +consistend,consistent +consistendly,consistently +consistendt,consistent +consistendtly,consistently consistenly,consistently consistens,consists consistensy,consistency consistentcy,consistently consistenty,consistently -consisteny,consistency +consisteny,consistency,consistent consistes,consists +consistuents,constituents +consit,consist +consitant,consistent +consited,consisted consitency,consistency +consitent,consistent +consitently,consistently +consiting,consisting +consitional,conditional +consits,consists consituencies,constituencies +consituency,constituency +consituent,constituent +consituents,constituents +consitute,constitute consituted,constituted consitutents,constituents +consitutes,constitutes +consituting,constituting consitution,constitution consitutional,constitutional +consitutuent,constituent +consitutuents,constituents +consitutute,constitute +consitututed,constituted +consitututes,constitutes +consitututing,constituting conslutant,consultant conslutants,consultant consluting,consulting +consol,console consolacion,consolation consolato,consolation consoldiate,consolidate @@ -5709,13 +11017,32 @@ conspiricy,conspiracy conspriacies,conspiracies conspriacy,conspiracy consqeuences,consequence +consquence,consequence +consquences,consequences +consquent,consequent +consquently,consequently +consrtuct,construct +consrtucted,constructed +consrtuctor,constructor +consrtuctors,constructors +consrtucts,constructs +consruction,construction +consructions,constructions +consructor,constructor +consructors,constructors +constain,constrain,contain +constained,constrained,contained +constaining,constraining,containing +constains,constrains,contains constaints,constraints constallation,constellation +constallations,constellations constanly,constantly constans,constants constanst,constants constantins,constants constantivs,constants +constantsm,constants constanty,constantly constarints,constraint constarnation,consternation @@ -5723,9 +11050,17 @@ constasnt,constants constast,constants constatn,constant constatnly,constantly +constatnt,constant +constatnts,constants +constcurts,constructs constently,constantly +constext,context constillation,constellation +consting,consisting constinually,continually +constistency,consistency +constists,consists +constitently,consistently constitition,constitution constititional,constitutional constituant,constituent @@ -5735,7 +11070,7 @@ constituates,constitutes constitucion,constitution constitucional,constitutional constitude,constitute -constitue,constitutes +constitue,constitutes,constitute constitued,constitute constituem,constitute constituer,constitute @@ -5757,26 +11092,60 @@ constitutn,constituents constitutues,constitute constituye,constitute constiutents,constituents +constly,costly constnatly,constantly +constract,construct +constracted,constructed constracting,constructing constraction,construction +constractor,constructor +constractors,constructors constracts,constructs +constraing,constraining,constraint constrainsts,constraints -constrait,constraints +constraintes,constraints +constrait,constraints,constraint constraits,constraints +constrans,constrains constransi,constraints +constrant,constraint constrants,constraints +constrast,contrast +constrasts,contrasts constrat,constraint constrating,constraint +constratints,constraints +constraucts,constructs +constrct,construct,constrict +constrcted,constructed,constricted +constrcting,constructing,constricting +constrction,construction,constriction +constrctions,constructions,constrictions +constrcts,constructs,constricts +constrcuct,construct +constrcut,construct +constrcuted,constructed +constrcution,construction +constrcutor,constructor +constrcutors,constructors +constrcuts,constructs constriants,constraints +constrollers,controllers +construc,construct construccion,construction -construced,constructed +construced,constructed,construed +construces,constructs construcing,constructing construcion,construction construciton,construction construcive,constructive +construcor,constructor construcs,constructs +constructcor,constructor constructeds,constructs +constructer,constructor +constructers,constructors +constructes,constructs constructicon,construction constructie,constructive constructief,constructive @@ -5788,21 +11157,56 @@ constructiong,constructing constructivo,construction constructo,construction constructos,constructs +constructred,constructed +constructt,construct +constructted,constructed +constructting,constructing +constructtor,constructor +constructtors,constructors +constructts,constructs +constructued,constructed constructur,constructor +constructure,constructor constructus,constructs construde,construed construint,constraint construits,constructs +construktor,constructor +construnctor,constructor +construrtors,constructors construst,constructs -construt,constructs +construt,constructs,construct +construtced,constructed construted,constructed +construter,constructor +construters,constructors +constrution,construction +construtor,constructor +construtors,constructors +consttruct,construct +consttructer,constructor +consttructers,constructors consttruction,construction +consttructor,constructor +consttructors,constructors +constuct,construct +constucted,constructed +constucter,constructor +constucters,constructors +constucting,constructing constuction,construction +constuctor,constructor +constuctors,constructors +constucts,constructs +consturct,construct consturcted,constructed consturction,construction +consturctor,constructor constured,construed +consuder,consider consueling,consulting consuelling,counselling +consuemr,consumer consulant,consultant consulation,consolation consultaion,consultation @@ -5816,6 +11220,7 @@ consultato,consultation consultent,consultant consumate,consummate consumated,consummated +consumating,consummating consumation,consumption consumbale,consumables consumbales,consumables @@ -5827,31 +11232,56 @@ consumirem,consumerism consumires,consumerism consumirse,consumerism consumiste,consumes +consummed,consumed consumpion,consumption consums,consumes +consumtion,consumption +contacentaion,concatenation contacs,contacts contactes,contacts contaction,contacting contactos,contacts +contagen,contagion contageous,contagious contagios,contagious contagiosa,contagious contagioso,contagious contagiosum,contagious +contaier,container contaigous,contagious contaiminate,contaminate +contaiminated,contaminated +contaiminating,contaminating +containa,contain containd,contained +containe,contain,contained,container,contains +containees,containers containered,contained +containerr,container containes,contains containg,containing +containging,containing containig,containing +containings,containing +containining,containing +containint,containing containmemt,containment +containn,contain +containner,container +containners,containers +containns,contains containors,containers +containt,contain,content +containted,contained +containter,container containters,containers containting,containing containts,contains +containuations,continuations contaire,containers contais,contains +contaisn,contains +contaiun,contain contaminacion,contamination contaminanted,contaminated contaminatie,contaminated @@ -5863,17 +11293,33 @@ contaminents,containment contaminted,contaminated contamporaries,contemporaries contamporary,contemporary +contan,contain contancting,contracting +contaned,contained contanimate,contaminated contanimated,contaminated contanimation,contamination contaniments,containment +contanined,contained +contaning,containing +contanins,contains +contans,contains +contant,constant,content contanti,contacting contanting,contacting -contast,contacts +contants,constants,contents +contary,contrary +contast,contacts,contrast,contest +contatenated,concatenated +contating,contacting,containing +contect,contact,context,connect contection,contention contectual,contextual +contein,contain +conteined,contained conteiners,contenders +conteining,containing +conteins,contains contempate,contemplate contemperary,contemporary contemplare,contemplate @@ -5885,32 +11331,42 @@ contemporany,contemporary contemporay,contemporary contempory,contemporary contemt,contempt +conten,contain contenants,continents +contence,contents contencion,contention contencious,contentious contendor,contender contendors,contenders +contened,contained,contend contenental,continental contenents,continents +contener,container +conteners,containers conteneurs,contenders contengency,contingency contengent,contingent +contenht,content contenintal,continental contenplate,contemplate contenplating,contemplating -contens,contents +contens,contents,contains contense,contenders contension,contention contensious,contentious contenst,contents contentants,contestants contentas,contents +contentended,contended contentes,contents contentino,contention contentios,contentious +contentn,content contentos,contents contentous,contentious +contentss,contents contentuous,contentious +contermporaneous,contemporaneous contess,contests contestais,contests contestans,contests @@ -5922,14 +11378,20 @@ contestents,contestants contestes,contests contestion,contention contestors,contests -contexta,contextual +contet,contest,content,context +contets,contents,contexts +contex,context +contexta,contextual,context contextes,contexts contextful,contextual contextl,contextual contextos,contexts contextuel,contextual contextura,contextual +contexual,contextual +contiains,contains contian,contain +contianed,contained contianer,container contianers,containers contianing,containing @@ -5938,16 +11400,25 @@ contians,contains contibute,contribute contibuted,contributed contibutes,contributes +contibutor,contributor contientous,contentious contigent,contingent contigents,continents -contigious,contagious +contigious,contagious,contiguous +contigiously,contiguously contignent,contingent +contignuous,contiguous +contigous,contiguous +contiguious,contiguous +contiguities,continuities +contiguos,contiguous contimplate,contemplate contimplating,contemplating +continaing,containing continant,continental continants,continents -contine,continue +contination,continuation +contine,continue,contain contined,continued continenal,continental continenet,continents @@ -5966,10 +11437,14 @@ contingecy,contingency contingeny,contingency contingient,contingent contingincy,contingency +continging,containing +contingous,contiguous +continguous,contiguous continient,contingent continious,continuous continiously,continuously continiuty,continuity +continoue,continue continous,continuous continously,continuously contintent,contingent @@ -5984,6 +11459,8 @@ continuating,continuation continuativo,continuation continuato,continuation continueing,continuing +continuely,continually +continuem,continuum continuemos,continues continuent,contingent continueous,continuous @@ -5997,7 +11474,10 @@ continunity,continuity continuons,continuous continuos,continuous continuosly,continuously -continus,continues +continure,continue +continus,continues,continue,continuous +continuse,continues +continusly,continuously continut,continuity continute,continue continuting,continuing @@ -6011,26 +11491,48 @@ contirbuted,contributed contirbution,contribution contirbutors,contributors contitnent,contingent +contiuation,continuation +contiue,continue +contiuguous,contiguous +contiuing,continuing contiunal,continual contiunally,continually contiunation,continuation contiuning,containing contiunity,continuity +contnt,content +contol,control +contoler,controller +contoller,controller +contollers,controllers +contolls,controls +contols,controls +contongency,contingency +contorl,control +contorled,controlled contorller,controllers +contorls,controls +contoroller,controller contrabution,contribution contraccion,contraction contraceptie,contraceptives contraceptivo,contraception contraceptivos,contraceptives +contraciction,contradiction +contracictions,contradictions contracing,contracting +contracition,contradiction +contracitions,contradictions contracr,contractor contracs,contracts contractar,contractor contracter,contractor +contracters,contractors contractin,contraction contracto,contraction contractos,contracts contraddice,contradicted +contradically,contradictory contradiccion,contradiction contradice,contradicted contradices,contradicts @@ -6048,8 +11550,14 @@ contradictiong,contradicting contradicton,contradiction contradictons,contradicts contradtion,contraction +contrained,contained,constrained +contraining,constraining +contraint,constraint +contraints,constraints +contraitns,constraints contraticted,contradicted contraticting,contradicting +contraveining,contravening contravercial,controversial contraversial,controversial contraversy,controversy @@ -6092,28 +11600,45 @@ contridict,contradict contridicted,contradicted contridictory,contradictory contridicts,contradicts +contries,countries contritutions,contributions -contriubte,contributes +contriubte,contributes,contribute +contriubted,contributed +contriubtes,contributes +contriubting,contributing +contriubtion,contribution +contriubtions,contributions contriversial,controversial contriversy,controversy +contrl,control +contrller,controller +contro,control controception,contraception controceptives,contraceptives controdicting,contradicting controdiction,contradiction controdictions,contradictions +controlable,controllable controlas,controls +controle,control,controlled,controller controled,controlled controlelr,controllers -controlers,controls -controles,controls +controlelrs,controllers +controler,controller +controlers,controls,controllers +controles,controls,controllers controleurs,controllers controling,controlling controll,control controlleras,controllers +controllerd,controlled controlles,controls controlllers,controllers +controllor,controller controllore,controllers controlls,controls +contronl,control +controoler,controller controvercial,controversial controvercy,controversy controverial,controversial @@ -6123,30 +11648,55 @@ controversa,controversial controversal,controversial controversary,controversy controversey,controversy +controversials,controversial controversity,controversy controvertial,controversial controvery,controversy controvesy,controversy +contrtoller,controller contrubite,contributes contrubute,contribute contrubutes,contributes -contructing,contracting +contruct,construct +contructed,constructed +contructing,contracting,constructing contruction,construction -contructions,contractions -contructors,contractors +contructions,contractions,constructions +contructor,constructor +contructors,contractors,constructors +contructs,constructs +contry,country +contryie,countryie +contsruction,construction +contstant,constant +contstants,constants +contstraint,constraint +contstructing,constructing contstruction,construction contuining,continuing contuinity,continuity +contur,contour +contzains,contains +conuntry,country +conusmer,consumer +convaless,convalesce convaluted,convoluted +convax,convex +convaxiity,convexity +convaxly,convexly +convaxness,convexness convcition,convictions conveinence,convenience conveinent,convenient conveinently,conveniently +conveinience,convenience +conveinient,convenient conveluted,convoluted convenant,covenant convencen,convenience convencion,convention convencional,conventional +convenction,convention,convection conveneince,convenience conveniance,convenience conveniant,convenient @@ -6156,20 +11706,32 @@ conveniente,convenience conveniet,convenient convenietly,conveniently convenince,convenience +conveninent,convenient convenit,convenient +convense,convince +convension,convention,conversion convential,conventional +conventient,convenient conventinal,conventional conventionnal,conventional convento,convention +convenvient,convenient +conver,convert converastion,conversations converastions,conservation converdation,conservation +convered,converted,covered converesly,conversely +convereted,converted +convergance,convergence convergens,converse -converison,conversions +convering,converting,covering +converion,conversion +converions,conversions +converison,conversions,conversion converitble,convertible converning,converting -convers,converts +convers,converts,converse,convert conversacion,conversation conversacional,conversational conversaion,conversion @@ -6191,18 +11753,26 @@ conversin,conversions conversino,conversions conversiones,conversions conversley,conversely -conversoin,conversions +conversly,conversely +conversoin,conversions,conversion conversons,conversions -converst,converts +converssion,conversion +converst,converts,convert converstaion,conversation converstaional,conversational converstaions,conversations -converstion,conversion +converstion,conversion,conversation +converstions,conversions,conversations +convertable,convertible convertables,convertibles +convertation,conversation,conversion +convertations,conversations,conversions +convertet,converted convertiable,convertible convertibile,convertible convertie,convertible convertion,conversion +convertions,conversions convertire,converter convertirea,converter convertirle,convertible @@ -6212,9 +11782,20 @@ convertis,converts convertr,converter convervation,conservation convervatism,conservatism +convery,convert converying,converting converzation,conservation +convesion,conversion +convesions,conversions convesration,conservation +convet,convert +conveted,converted +conveter,converter +conveters,converters +conveting,converting +convetion,convention +convets,converts +convexe,convex,convexes conveyd,conveyed conveyered,conveyed conviccion,conviction @@ -6222,35 +11803,85 @@ conviced,convinced conviciton,conviction convicitons,convictions convicto,conviction +convience,convince,convenience convienence,convenience convienent,convenient convienently,conveniently +convienience,convenience convienient,convenient +convieniently,conveniently +conviguration,configuration +convigure,configure conviluted,convoluted +convination,combination convinceing,convincing convincente,convenient convincersi,convinces convincted,convince -convine,convince +convine,convince,combine +convineance,convenience +convineances,conveniences +convined,combined,convinced +convineient,convenient +convinence,convenience +convinences,conveniences +convinent,convenient +convinently,conveniently convingi,convincing +conviniance,convenience +conviniances,conveniences +convinience,convenience +conviniences,conveniences +conviniency,convenience +conviniencys,conveniences +convinient,convenient +conviniently,conveniently +convining,combining convinse,convinces convinsing,convincing +convinve,convince +convinved,convinced convinving,convincing +convirted,converted convirtible,convertible +convirting,converting +convised,convinced convoluded,convoluted convorsation,conversation convorsations,conversations convoulted,convoluted +convovle,convolve +convovled,convolved +convovling,convolving convseration,conservation +convserion,conversion convulated,convoluted convuluted,convoluted +conyak,cognac +coodinate,coordinate +coodinates,coordinates +coodrinate,coordinate +coodrinates,coordinates +cooger,cougar +cookoo,cuckoo cooldows,cooldowns cooldwons,cooldowns +coolent,coolant +coolot,culotte +coolots,culottes +coomand,command +coommand,command +coonstantly,constantly +coonstructed,constructed +coopearte,cooperate +coopeartes,cooperates cooperacion,cooperation cooperativo,cooperation cooperatve,cooperative cooporation,cooperation cooporative,cooperative +coordanate,coordinate +coordanates,coordinates coordenate,coordinate coordenated,coordinated coordenates,coordinates @@ -6260,6 +11891,9 @@ coordianted,coordinated coordiantes,coordinates coordiantion,coordination coordiantor,coordinator +coordiate,coordinate +coordiates,coordinates +coordiinates,coordinates coordinacion,coordination coordinador,coordinator coordinants,coordinates @@ -6272,21 +11906,58 @@ coordinato,coordination coordinaton,coordination coordinatore,coordinate coordinats,coordinates +coordindate,coordinate +coordindates,coordinates coordine,coordinate +coordines,coordinates +coording,according +coordingate,coordinate +coordingates,coordinates +coordingly,accordingly +coordiniate,coordinate +coordiniates,coordinates +coordinite,coordinate +coordinites,coordinates +coordinnate,coordinate +coordinnates,coordinates +coordintae,coordinate +coordintaes,coordinates +coordintate,coordinate +coordintates,coordinates +coordinte,coordinate +coordintes,coordinates +coorditate,coordinate coordonate,coordinate coordonated,coordinated coordonates,coordinates coordonation,coordination coordonator,coordinator +coorespond,correspond +cooresponded,corresponded +coorespondend,correspondent +coorespondent,correspondent cooresponding,corresponding +cooresponds,corresponds +cooridate,coordinate +cooridated,coordinated +cooridates,coordinates cooridnate,coordinate cooridnated,coordinated cooridnates,coordinates cooridnation,coordination cooridnator,coordinator -coorperation,cooperation -coorperations,corporations +coorinate,coordinate +coorinates,coordinates +coorination,coordination +coorperation,cooperation,corporation +coorperations,corporations,cooperations +cootdinate,coordinate +cootdinated,coordinated +cootdinates,coordinates +cootdinating,coordinating +cootdination,coordination copehnagen,copenhagen +copeing,copying copenaghen,copenhagen copenahgen,copenhagen copengagen,copenhagen @@ -6301,20 +11972,97 @@ copenhagun,copenhagen copenhangen,copenhagen copenhaven,copenhagen copenhegan,copenhagen +copiese,copies +copiing,copying +copiler,compiler +copletely,completely copmetitors,competitors +copmilation,compilation +copmonent,component +copmutations,computations +copntroller,controller +coponent,component +copoying,copying +coppermines,coppermine +coppied,copied +coppy,copy,choppy +copright,copyright +coprighted,copyrighted +coprights,copyrights +coproccessor,coprocessor +coproccessors,coprocessors +coprocesor,coprocessor coprorate,corporate coproration,corporation coprorations,corporations +coprright,copyright +coprrighted,copyrighted +coprrights,copyrights coprses,corpses +copstruction,construction +copuright,copyright +copurighted,copyrighted +copurights,copyrights +copute,compute +coputed,computed coputer,computer +coputes,computes +copver,cover +copyed,copied +copyeight,copyright +copyeighted,copyrighted +copyeights,copyrights +copyied,copied copyrighed,copyrighted copyrigted,copyrighted +copyrigth,copyright copyrigthed,copyrighted +copyrigths,copyrights +copyritght,copyright +copyritghted,copyrighted +copyritghts,copyrights +copyrught,copyright +copyrughted,copyrighted +copyrughts,copyrights +copys,copies +copytight,copyright +copytighted,copyrighted +copytights,copyrights +copyting,copying copywrite,copyright +corale,chorale coralina,carolina corasir,corsair coratia,croatia corcodile,crocodile +cordinate,coordinate +cordinates,coordinates +cordoroy,corduroy +cordump,coredump +corecct,correct +corecctly,correctly +corect,correct +corected,corrected +corecting,correcting +corection,correction +corectly,correctly +corects,corrects +coreespond,correspond +coregated,corrugated +corelate,correlate +corelated,correlated +corelates,correlates +corellation,correlation +corener,corner,coroner +coreolis,coriolis +corerct,correct +corerctly,correctly +corespond,correspond +coresponded,corresponded +corespondence,correspondence +coresponding,corresponding +coresponds,corresponds +corfirms,confirms coridal,cordial corinthains,corinthians corinthans,corinthians @@ -6325,11 +12073,23 @@ corinthiens,corinthians corinthinans,corinthians corinthinas,corinthians corinthins,corinthians +corispond,correspond cornithians,corinthians cornmitted,committed corollla,corolla corolloa,corolla +corordinate,coordinate +corordinates,coordinates +corordination,coordination +corosbonding,corresponding corosion,corrosion +corospond,correspond +corospondance,correspondence +corosponded,corresponded +corospondence,correspondence +corosponding,corresponding +corosponds,corresponds +corousel,carousel corparate,corporate corparation,corporation corparations,corporations @@ -6339,17 +12099,26 @@ corporacion,corporation corporatie,corporate corporativo,corporation corporativos,corporations +corpration,corporation corproate,corporate corproations,corporations +corproration,corporation +corprorations,corporations corpsers,corpses corralated,correlated corralates,correlates corralation,correlation +corrcect,correct +corrct,correct +corrdinates,coordinates corrdination,coordination corrdior,corridor correccion,correction correciton,corrections correclty,correctly +correcly,correctly +correctably,correctable +correctely,correctly correcters,correctors correctess,correctness correctin,correction @@ -6357,36 +12126,99 @@ correctings,corrections correctionals,corrections correctivo,correction correctivos,corrections +correctnes,correctness +correcton,correction correctons,corrections +correctures,correctors correcty,correctly +correctyly,correctly +correcxt,correct +correect,correct +correectly,correctly corregated,correlated correkting,correcting correktions,corrections correktness,correctness correlacion,correlation +correlasion,correlation correlatas,correlates +correlatd,correlated correlatie,correlated correlaties,correlates correlato,correlation correlatos,correlates +correllate,correlate +correllation,correlation +correllations,correlations +correnspond,correspond +corrensponded,corresponded +correnspondence,correspondence +correnspondences,correspondences +correnspondent,correspondent +correnspondents,correspondents +corrensponding,corresponding +corrensponds,corresponds +corrent,correct,current correnti,correcting +correograph,choreograph correponding,corresponding +correponds,corresponds +correponsing,corresponding correposding,corresponding correpsondence,correspondence correpsonding,corresponding +corresond,correspond +corresonded,corresponded +corresonding,corresponding +corresonds,corresponds +correspdoning,corresponding correspend,correspond +correspending,corresponding +correspinding,corresponding +correspnding,corresponding +correspodence,correspondence +correspoding,corresponding +correspoinding,corresponding +correspomd,correspond +correspomded,corresponded +correspomdence,correspondence +correspomdences,correspondences +correspomdent,correspondent +correspomdents,correspondents +correspomding,corresponding +correspomds,corresponds +correspondance,correspondence +correspondances,correspondences correspondant,correspondent correspondants,correspondents correspondece,correspondence +correspondend,correspondent correspondense,correspondence correspondente,correspondence corresponders,corresponds correspondes,corresponds +correspondg,corresponding correspondig,corresponding +corresponging,corresponding corresponing,corresponding +corresponsding,corresponding corresponsing,corresponding +correspont,correspond +correspontence,correspondence +correspontences,correspondences +correspontend,correspondent +correspontent,correspondent +correspontents,correspondents +corresponting,corresponding +corresponts,corresponds +correspoond,correspond +corressponding,corresponding +corret,correct +correted,corrected +corretion,correction corretly,correctly corridoor,corridor +corridoors,corridors corrilated,correlated corrilates,correlates corrilation,correlation @@ -6397,50 +12229,122 @@ corrisponded,corresponded corrispondence,correspondence corrisponding,corresponding corrisponds,corresponds +corrleation,correlation +corrleations,correlations corrolated,correlated corrolates,correlates corrolation,correlation +corrolations,correlations corrospond,correspond corrospondence,correspondence corrosponding,corresponding corrosponds,corresponds corrpution,corruption +corrrect,correct +corrrected,corrected +corrresponding,corresponding +corrresponds,corresponds +corrrupt,corrupt +corrrupted,corrupted +corrruption,corruption +corrspond,correspond +corrsponded,corresponded +corrsponding,corresponding +corrsponds,corresponds corrulates,correlates corrupcion,corruption +corrupeted,corrupted +corruptable,corruptible corruptin,corruption +corruptiuon,corruption corrupto,corruption corsari,corsair +corse,course corsiar,corsair +corsor,cursor corspes,corpses +corss,cross,course +corsses,crosses,courses corssfire,crossfire corsshair,crosshair +corsshairs,crosshairs corsspost,crosspost coruching,crouching +corus,chorus +corvering,covering corwbar,crowbar cosemtic,cosmetic cosemtics,cosmetics cosmeticas,cosmetics cosmeticos,cosmetics +cosnsrain,constrain +cosnsrained,constrained +cosntrain,constrain +cosntrains,constrains,constraints +cosntraint,constraint +cosntraints,constraints +cosntructed,constructed +cosntructor,constructor +cosnumer,consumer +cosolation,consolation +cosole,console +cosoled,consoled +cosoles,consoles +cosoling,consoling +costant,constant costitution,constitution costomizable,customizable costomization,customization +costruct,construct +costructer,constructor +costructor,constructor +costum,custom,costume +costumary,customary costumise,costumes costumizable,customizable costumization,customization costumizations,customization costumized,customized -costums,costumes +costums,costumes,customs cosutmes,costumes +cotain,contain +cotained,contained +cotainer,container +cotains,contains +cotave,octave +cotaves,octaves +cotnain,contain +cotnained,contained +cotnainer,container +cotnainers,containers +cotnaining,containing +cotnains,contains +cotranser,cotransfer +cotrasferred,cotransferred +cotrasfers,cotransfers +cotrol,control +cotrolled,controlled +cotrolling,controlling +cotrols,controls +cotten,cotton coucil,council -coudl,could +coud,could +coudl,could,cloud coudlnt,couldnt +coul,could couldnot,couldnt coulmns,columns coulndt,couldnt coulored,colored +couloumb,coulomb +coult,could +coummunities,communities +coummunity,community +coumpound,compound +coumpounds,compounds counceling,counseling -councellor,councillor -councellors,councillors +councellor,councillor,counsellor,councillor +councellors,councillors,counsellors,councillors councelors,counselors councidental,coincidental councidentally,coincidentally @@ -6448,7 +12352,14 @@ councilers,councils counciles,councils councills,councils councilos,councils -counries,countries +cound,could,count +counding,counting +coundition,condition +counds,counts +counld,could +counpound,compound +counpounds,compounds +counries,countries,counties counrtyside,countryside counseil,counsel counselers,counselors @@ -6462,6 +12373,9 @@ counsle,counsel counsole,counsel counsolers,counselors counsoling,counseling +countain,contain +countainer,container +countainers,containers countains,contains countepart,counteract counteratk,counteract @@ -6478,12 +12392,19 @@ counterfeight,counterfeit counterfest,counterfeit counterfiet,counterfeit counterfiets,counterfeit +counterfit,counterfeit counterfited,counterfeit +counterfits,counterfeits counteries,counters +countermeausure,countermeasure +countermeausures,countermeasures counterpaly,counterplay +counterpar,counterpart counterpary,counterplay counterpath,counterpart counterpats,counterparts +counterpoart,counterpart +counterpoarts,counterparts counterpont,counterpoint counterporductive,counterproductive counterprodutive,counterproductive @@ -6494,15 +12415,21 @@ countert,counteract countertrap,counterpart countertraps,counterparts countes,counters -countires,countries +countinue,continue +countinueq,continueq,continue +countires,countries,counties countoring,countering +countours,contours,counters +countr,counter,contour,country,county countres,counters countriside,countryside +countrs,counters,contours,countries countrycide,countryside countryies,countryside countrying,countering countrywides,countryside countrywise,countryside +cource,course,coerce,source courcework,coursework courching,crouching coursefork,coursework @@ -6514,10 +12441,23 @@ courthourse,courthouse courtrom,courtroom courtrooom,courtroom courtsey,courtesy -coururier,courier +coururier,courier,couturier +couse,course,cause +couses,courses,causes cousines,cousins +cousing,cousin cousings,cousins cousnelors,counselors +couted,counted +couter,counter +coutermeasuere,countermeasure +coutermeasueres,countermeasures +coutermeasure,countermeasure +coutermeasures,countermeasures +couterpart,counterpart +couters,counters,routers,scouters +couting,counting +coutner,counter coutneract,counteract coutnered,countered coutnerfeit,counterfeit @@ -6528,33 +12468,86 @@ coutnerplay,counterplay coutnerpoint,counterpoint coutnerproductive,counterproductive coutners,counters +couuld,could covanent,covenant +covarage,coverage +covarages,coverages +covarege,coverage covenat,covenant covenental,covenant -coverted,converted +covention,convention +coventions,conventions +covere,cover +coveres,covers +coverge,coverage,converge +coverges,coverages,converges +coverred,covered +coversion,conversion +coversions,conversions +coverted,converted,covered,coveted +coverting,converting covnersation,conservation +covnert,convert +covriance,covariance +covriate,covariate +covriates,covariates coyotees,coyotes +coyp,copy +coypright,copyright +coyprighted,copyrighted +coyprights,copyrights +coyright,copyright +coyrighted,copyrighted +coyrights,copyrights coytoes,coyotes +cpacities,capacities +cpacity,capacity cpatains,captains -cpoy,coy +cpation,caption +cpoy,coy,copy +cppp,cpp crabine,carbine +crace,grace,crate +craches,crashes,caches,crutches +craete,create +craeting,creating,crating +crahed,crashed +crahes,crashes +crahs,crash,crass +crahses,crashes cralwed,crawled cranberrry,cranberry cranbery,cranberry crankenstein,frankenstein craotia,croatia crapenter,carpenter +crashaes,crashes +crasheed,crashed +crashees,crashes +crashess,crashes +crashs,crashes craweld,crawled crayones,crayons +creaate,create creacionism,creationism +creaed,created creaeted,created creamic,ceramic +creasoat,creosote +creastor,creator +creatation,creation +createa,create +createable,creatable +createdd,created createin,creatine +createing,creating +createive,creative createn,creatine -creater,creature +creater,creature,creator createur,creature creatie,creatine creatien,creatine +creationg,creation,creating creationis,creations creationisim,creationism creationistas,creationists @@ -6573,21 +12566,42 @@ creativelly,creatively creativey,creatively creativily,creatively creativley,creatively +creatning,creating +creatre,create +creatred,created +creats,creates creatue,creature +credate,created credencials,credentials credentails,credentials credentaisl,credentials +credetial,credential +credetials,credentials credibillity,credibility credibilty,credibility credientals,credentials +credintial,credential credintials,credentials +credis,credits +credists,credits +creditted,credited creedence,credence creeperest,creepers creepes,creepers creepgin,creeping creepig,creeping +cresent,crescent +cresits,credits +cretae,create +cretaed,created +cretaes,creates +cretaing,creating +cretates,creates +creted,created creulty,cruelty +crewsant,croissant crhistmas,christmas +cricital,critical cricitising,criticising cricketts,crickets cricles,circles @@ -6610,15 +12624,22 @@ cringeworty,cringeworthy cringewothy,cringeworthy cringewrothy,cringeworthy cringyworthy,cringeworthy +crirical,critical +critcial,critical +criteak,critique critera,criteria critereon,criterion criterias,criteria +criteriom,criterion criticable,critical +criticall,critical criticallity,critically criticaly,critically criticarlo,critical criticas,critics critices,critics +criticial,critical +criticially,critically criticicing,criticising criticie,criticise criticies,criticise @@ -6643,19 +12664,22 @@ criticos,critics criticts,critics criticus,critics critiera,criteria +critiical,critical critisice,criticise critisiced,criticized critisicing,criticizing critisicm,criticism critisicms,criticisms critisicsm,criticisms -critising,criticising +critising,criticising,criticising critisiscm,criticisms critisising,criticising critisism,criticism critisisms,criticisms -critisize,criticize -critisizes,criticizes +critisize,criticize,criticize +critisized,criticized,criticized +critisizes,criticizes,criticizes +critisizing,criticizing,criticizing critisizms,criticisms critized,criticized critiziced,criticized @@ -6667,29 +12691,48 @@ critizisms,criticisms critizized,criticized critizizing,criticizing croatioa,croatia +croch,crotch +crockadile,crocodile crockodiles,crocodiles crocodille,crocodile crocodiller,crocodile crocodilule,crocodile +cronological,chronological +cronologically,chronologically croporation,corporation croporations,corporations +croppped,cropped cropses,corpses +cros,cross crosair,corsair +croshet,crochet crossfie,crossfire crossfiter,crossfire crossfiters,crossfire crosshar,crosshair crosshiar,crosshair crossifre,crossfire +crossin,crossing crosspot,crosspost crowbahr,crowbar +crowdsigna,crowdsignal +crowkay,croquet crowm,crown crpytic,cryptic +crrespond,correspond crsytal,crystal +crsytalline,crystalline +crsytallisation,crystallisation +crsytallise,crystallise +crsytallization,crystallization +crsytallize,crystallize +crsytallographic,crystallographic +crsytals,crystals crtical,critical crticised,criticised cruasder,crusader cruciaal,crucial +crucialy,crucially crucibe,crucible crucibel,crucible crucifiction,crucifixion @@ -6697,6 +12740,8 @@ cruetly,cruelty cruical,crucial cruicble,crucible crulety,cruelty +cruncing,crunching +crurrent,current crusdae,crusade crusdaer,crusader crusdaers,crusaders @@ -6705,11 +12750,18 @@ crusiers,cruisers crusies,cruises crusiing,cruising crusive,cursive +crusor,cursor crutchers,crutches crutchetts,crutches crutchs,crutches cruthces,crutches +crutial,crucial +crutially,crucially +crutialy,crucially crypitc,cryptic +crypted,encrypted +cryptocraphic,cryptographic +cryptograpic,cryptographic crystalens,crystals crystalisation,crystallisation crystalisk,crystals @@ -6719,17 +12771,27 @@ crystalus,crystals crystalys,crystals crystas,crystals crystsl,crystals +cryto,crypto crytopgraphic,cryptographic crytpic,cryptic +crytpo,crypto crytsal,crystal cthluhu,cthulhu cthuhlu,cthulhu cthulhlu,cthulhu cthulluh,cthulhu cthuluh,cthulhu +ctificate,certificate +ctificated,certificated +ctificates,certificates +ctification,certification ctuhlhu,cthulhu cuacasian,caucasian cuasality,causality +cuasation,causation +cuase,cause +cuased,caused +cuases,causes cuasing,causing cuatiously,cautiously cubcile,cubicle @@ -6737,7 +12799,11 @@ cubilce,cubicle cubpoard,cupboard cuddels,cuddles cuddleys,cuddles +cuestion,question cuestionable,questionable +cuestioned,questioned +cuestions,questions +cuileoga,cuileog culiminating,culminating culitvate,cultivate culprint,culprit @@ -6754,70 +12820,173 @@ culutral,cultural culutrally,culturally cumbersone,cumbersome cumbursome,cumbersome +cumlative,cumulative +cummand,command +cummulative,cumulative +cummunicate,communicate cumpolsory,compulsory cumulatative,cumulative +cumulattive,cumulative cumulitive,cumulative +cuncurency,concurrency cuntaminated,contaminated +cunter,counter cupbaord,cupboard cupboad,cupboard cupborad,cupboard cuplrit,culprit curatin,curtain +curch,church curcial,crucial curcible,crucible curcuit,circuit +curcuits,circuits curcumcision,circumcision curcumference,circumference curcumstance,circumstance curcumstances,circumstances curcumstantial,circumstantial +cureful,careful +curefully,carefully +curefuly,carefully curelty,cruelty +curent,current +curentfilter,currentfilter +curently,currently +curernt,current +curerntly,currently curiostiy,curiosity +curiousities,curiosities +curiousity,curiosity curiser,cruiser curisers,cruisers curising,cruising curisoity,curiosity curisve,cursive +curnilinear,curvilinear currancies,currencies currate,curate currecny,currency +currect,correct,current +currected,corrected +currecting,correcting +currectly,correctly,currently +currects,corrects,currents +curreent,current +curreents,currents +curremt,current +curremts,currents +curren,current currence,currencies currenctly,currency currenices,currencies currenlty,currently currenly,currently +currennt,current +currenntly,currently +currennts,currents currens,currents currentfps,currents +currentl,currently +currentlly,currently currentlys,currents currentpos,currents +currentry,currently currentusa,currents currenty,currently curreny,currency +curresponding,corresponding currest,currents +curretly,currently +curretnly,currently curriculem,curriculum curriculim,curriculum curricullum,curriculum curriculm,curriculum curriences,currencies +currious,curious +currnet,current +currnt,current +currntly,currently curroption,corruption +curros,cursor +currrency,currency +currrent,current +currrently,currently +curruent,current +currupt,corrupt +curruptable,corruptible +currupted,corrupted +curruptible,corruptible +curruption,corruption +curruptions,corruptions +currupts,corrupts +currus,cirrus cursade,crusade cursader,crusader cursaders,crusaders +curser,cursor +cursos,cursors,cursor +cursot,cursor +cursro,cursor curtian,curtain +curvelinear,curvilinear custamizable,customizable custcene,cutscene custcenes,cutscenes custimizable,customizable custimized,customized +custoisable,customisable +custoisation,customisation +custoise,customise +custoised,customised +custoiser,customiser +custoisers,customisers +custoising,customising +custoizable,customizable +custoization,customization +custoize,customize +custoized,customized +custoizer,customizer +custoizers,customizers +custoizing,customizing +customable,customizable +custome,custom,customs,costume,customer +customicable,customisable,customizable +customie,customize +customied,customized customizabe,customizable customizaton,customization customizble,customizable customizeble,customizable customizible,customizable +customsied,customised customzied,customized +custon,custom +custonary,customary +custoner,customer +custoners,customers +custonisable,customisable +custonisation,customisation +custonise,customise +custonised,customised +custoniser,customiser +custonisers,customisers +custonising,customising +custonizable,customizable +custonization,customization +custonize,customize +custonized,customized +custonizer,customizer +custonizers,customizers +custonizing,customizing +custons,customs +custumised,customised custumizable,customizable custumization,customization custumized,customized +cuted,cut,cute,cuter +cutom,custom cutsceen,cutscene cutsceens,cutscenes cutscence,cutscene @@ -6826,61 +12995,191 @@ cutscens,cutscenes cutscenses,cutscene cutsence,cutscene cutsences,cutscenes +cutted,cut +cuurently,currently +cuves,curves,cubes,caves +cuvre,curve,cover +cuvres,curves,covers cuztomizable,customizable cuztomization,customization +cvignore,cvsignore cxan,cyan cyandie,cyanide +cycic,cyclic cyclinder,cylinder +cyclinders,cylinders cyclistes,cyclists cyclits,cyclist cycloen,cyclone cycolps,cyclops +cycular,circular +cylcic,cyclic +cylcical,cyclical cylcist,cyclist cylcists,cyclists cylcone,cyclone cylcops,cyclops +cyle,cycle +cylic,cyclic +cylider,cylinder +cyliders,cylinders cylidner,cylinder cylindre,cylinder cylindres,cylinders +cylnder,cylinder +cylnders,cylinders +cylynders,cylinders +cymk,cmyk cynaide,cyanide cynicisim,cynicism cynisicm,cynicism +cyphersuite,ciphersuite +cyphersuites,ciphersuites +cyphertext,ciphertext +cyphertexts,ciphertexts +cyprt,crypt +cyprtic,cryptic +cyprto,crypto +cyrllic,cyrillic cyrptic,cryptic +cyrpto,crypto +cyrrent,current +cyrrilic,cyrillic cyrstal,crystal +cyrstalline,crystalline +cyrstallisation,crystallisation +cyrstallise,crystallise +cyrstallization,crystallization +cyrstallize,crystallize cyrstals,crystals +cyrto,crypto +cywgin,cygwin +daa,data +dabase,database dabilitating,debilitating +daclaration,declaration dacquiri,daiquiri +dadlock,deadlock daed,dead -dael,deal +dael,deal,dial,dahl +daemonified,daemonised,daemonized +dafault,default +dafaults,defaults +dafaut,default +dafualt,default +dafualted,defaulted +dafualts,defaults dagners,dangers dahsboard,dashboard daimond,diamond daimonds,diamonds +daita,data +dake,take dalmation,dalmatian +dalta,delta damenor,demeanor +dameon,daemon,demon,damien +damge,damage dammage,damage +dammages,damages +danceing,dancing +dandidates,candidates dangeros,dangers dangeroulsy,dangerously dangerouly,dangerously dangerousely,dangerously dangeroys,dangerously dangerus,dangers +daplicating,duplicating darcula,dracula dardenelles,dardanelles dargons,dragons darkenss,darkness darkets,darkest darnkess,darkness +dasdot,dashdot dashbaord,dashboard dashboad,dashboard +dashbord,dashboard +dashbords,dashboards +dashs,dashes +dasy,daisy +databaase,database +databaases,databases +databae,database +databas,database +databsae,database +databsaes,databases +databse,database +databses,databases +datadsir,datadir +dataet,dataset +dataets,datasets +datas,data +datastrcuture,datastructure +datastrcutures,datastructures +datastrem,datastream +datatbase,database +datatbases,databases +datatgram,datagram +datatgrams,datagrams +datatore,datastore +datatores,datastores +datatpe,datatype +datatpes,datatypes +datatpye,datatype +datatpyes,datatypes +datatset,dataset +datatsets,datasets +datatstructure,datastructure +datatstructures,datastructures +datattype,datatype +datattypes,datatypes +datatye,datatype +datatyep,datatype +datatyepe,datatype +datatyepes,datatypes +datatyeps,datatypes +datatyes,datatypes +datatyoe,datatype +datatyoes,datatypes +datatytpe,datatype +datatytpes,datatypes datbase,database +datbases,databases +datea,date,data +datecreatedd,datecreated +datection,detection +datee,date +datset,dataset +datsets,datasets +daty,data,date +daugher,daughter daugther,daughter daugthers,daughters daulity,duality davantage,advantage dawrves,dwarves +dchp,dhcp +dcok,dock +dcoked,docked +dcoker,docker +dcokerd,dockerd,docked,docker +dcoking,docking +dcoks,docks +dcument,document +dcumented,documented +dcumenting,documenting +dcuments,documents ddogers,dodgers ddoging,dodging +deacitivation,deactivation +deacitvated,deactivated +deactivatiion,deactivation +deactive,deactivate +deactiveate,deactivate +deactived,deactivated +deactiving,deactivating deadlfit,deadlift deadlfits,deadlifts deadlifs,deadlifts @@ -6888,43 +13187,149 @@ deadlifters,deadlifts deadlit,deadlift deadpol,deadpool deadpoool,deadpool +deaemon,daemon +deafault,default deafeted,defeated +deafualt,default +deafualts,defaults deafult,default +deafulted,defaulted deafults,defaults deahtly,deathly +deail,deal +deailing,dealing +deaktivate,deactivate +deaktivated,deactivated +dealed,dealt dealerhsip,dealerships dealershits,dealerships dealershp,dealerships +dealilng,dealing +dealloacte,deallocate +deallocaed,deallocated +dealocate,deallocate +dealte,delete dealying,delaying +deamand,demand +deamanding,demanding +deamands,demands +deambigate,disambiguate +deambigates,disambiguates +deambigation,disambiguation +deambiguage,disambiguate +deambiguages,disambiguates +deambiguate,disambiguate +deambiguates,disambiguates +deambiguation,disambiguation deamenor,demeanor +deamiguate,disambiguate +deamiguates,disambiguates +deamiguation,disambiguation +deamon,daemon +deamonified,daemonised,daemonized +deamonisation,daemonisation +deamonise,daemonise +deamonised,daemonised +deamonises,daemonises +deamonising,daemonising +deamonization,daemonization +deamonize,daemonize +deamonized,daemonized +deamonizes,daemonizes +deamonizing,daemonizing +deamons,daemons +deassering,deasserting +deatch,detach +deatched,detached +deatches,detaches +deatching,detaching deathamtch,deathmatch deathcat,deathmatch deathmacth,deathmatch deathmath,deathmatch deatils,details +deativate,deactivate +deativated,deactivated +deativates,deactivates +deativation,deactivation deatlhy,deathly +deaults,defaults +deauthenication,deauthentication +debain,debian debateable,debatable +debbuger,debugger +debgu,debug +debgug,debug +debguging,debugging +debiab,debian +debloking,deblocking +debth,depth +debths,depths debuffes,debuffs debufffs,debuffs +debufs,debugfs +debugee,debuggee +debuger,debugger +debugg,debug +debugginf,debugging +debuggs,debugs +debuging,debugging +decaffinated,decaffeinated +decalare,declare +decalared,declared +decalares,declares +decalaring,declaring +decalration,declaration +decalrations,declarations +decalratiosn,declarations decalre,declare decalred,declared decalres,declares decalring,declaring +decapsulting,decapsulating +decathalon,decathlon +deccelerate,decelerate decembeard,december decembre,december +decemer,december +decend,descend decendant,descendant decendants,descendants -decendent,descendent -decendents,descendents +decendend,descendent,descendent,descended +decendent,descendent,descendent +decendentant,descendant +decendentants,descendants +decendents,descendents,descendents +decending,descending decensitized,desensitized decentraliced,decentralized decentrilized,decentralized deceptionist,receptionist deceptivley,deceptive +deciaml,decimal +deciamls,decimals +decices,decides +decidate,dedicate +decidated,dedicated +decidates,dedicates decideable,decidable decidely,decidedly +decie,decide +decied,decide,decided +deciedd,decided +deciede,decide +decieded,decided +deciedes,decides +decieding,deciding +decieds,decides +deciemal,decimal +decies,decides +decieve,deceive decieved,deceived +decieves,deceives +decieving,deceiving decifits,deficits +decimials,decimals decipted,depicted decipting,depicting deciption,depiction @@ -6932,72 +13337,287 @@ deciptions,depictions decisiones,decisions decisivie,decisive decison,decision +decission,decision +declar,declare declaracion,declaration declarase,declares declarasen,declares declaraste,declares +declarated,declared +declaratinos,declarations +declaratiom,declaration +declaraton,declaration +declaratons,declarations +declard,declared +declarded,declared declareation,declaration declarees,declares declaremos,declares -declars,declares +declaritive,declarative +declaritively,declaratively +declarnig,declaring +declars,declares,declared +declartated,declared +declartation,declaration +declartations,declarations +declartative,declarative +declartator,declarator +declartators,declarators +declarted,declared +declartion,declaration +declartions,declarations +declartiuon,declaration +declartiuons,declarations +declartiuve,declarative +declartive,declarative +declartor,declarator +declartors,declarators declase,declares +declataions,declarations +declatation,declaration +declatations,declarations +declated,declared +declation,declaration +declations,declarations +declatory,declaratory declears,declares decleration,declaration +declerations,declarations declinig,declining declinining,declining decloration,declaration +declration,declaration decmeber,december decoartions,decoration +decocde,decode +decocded,decoded +decocder,decoder +decocders,decoders +decocdes,decodes +decocding,decoding +decocdings,decodings +decodded,decoded +decodding,decoding +decodeing,decoding decomissioned,decommissioned +decomissioning,decommissioning +decommissionn,decommission +decommissionned,decommissioned +decommpress,decompress +decomoposition,decomposition decomposeion,decomposition +decomposion,decomposition decomposit,decompose decomposited,decomposed decompositing,decomposing decomposits,decomposes +decompostion,decomposition +decompostition,decomposition +decompres,decompress +decompresed,decompressed +decompreser,decompressor +decompreses,decompresses +decompresing,decompressing +decompresion,decompression +decompresor,decompressor +decompressd,decompressed +decompresser,decompressor +decompse,decompose +decond,decode +deconde,decode +deconded,decoded +deconder,decoder +deconders,decoders +decondes,decodes +deconding,decoding +decondings,decodings +deconstract,deconstruct +deconstracted,deconstructed +deconstrcutor,deconstructor +decopose,decompose +decoposes,decomposes decoracion,decoration +decoraded,decorated decoratie,decorative decoratieve,decorative decoratin,decorations decorativo,decoration decorativos,decorations +decoratrion,decoration +decorde,decode +decorded,decoded +decorder,decoder +decorders,decoders +decordes,decodes +decording,decoding +decordings,decodings decoritive,decorative +decorrellation,decorrelation +decose,decode +decosed,decoded +decoser,decoder +decosers,decoders +decoses,decodes +decosing,decoding +decosings,decodings decotations,decorations decpetion,deception decpetive,deceptive +decraesing,decreasing,deceasing +decrasing,decreasing,deceasing +decration,decoration +decreace,decrease +decreas,decrease +decremenet,decrement +decremenetd,decremented +decremeneted,decremented +decrese,decrease +decresing,decreasing,deceasing decress,decrees decribe,describe decribed,described decribes,describes decribing,describing +decription,description +decriptions,descriptions +decriptor,descriptor +decriptors,descriptors +decrmenet,decrement +decrmenetd,decremented +decrmeneted,decremented +decroation,decoration decroative,decorative +decrpt,decrypt +decrpted,decrypted +decrption,decryption +decrytion,decryption decscription,description decsend,descend decsendants,descendants decsended,descended decsending,descending +decsiptors,descriptors +decsribed,described +decsriptor,descriptor +decsriptors,descriptors +decstiption,description +decstiptions,descriptions dectect,detect +dectecte,detect,detected,detects +dectected,detected +dectecting,detecting +dectection,detection +dectector,detector +dectivate,deactivate +decutable,deductible +decutables,deductibles +decypher,decipher +decyphered,deciphered +ded,dead +dedault,default +dedected,detected +dedection,detection dedicacion,dedication dedicato,dedication +dedidated,dedicated dedikation,dedication +dedly,deadly deducatble,deductible deducitble,deductible +deductable,deductible +deductables,deductibles deductiable,deductible deductibe,deductible deductie,deductible +deduplacate,deduplicate +deduplacated,deduplicated +deduplacates,deduplicates +deduplacation,deduplication +deduplacte,deduplicate +deduplacted,deduplicated +deduplactes,deduplicates +deduplaction,deduplication +deduplaicate,deduplicate +deduplaicated,deduplicated +deduplaicates,deduplicates +deduplaication,deduplication +deduplate,deduplicate +deduplated,deduplicated +deduplates,deduplicates +deduplation,deduplication +dedupliate,deduplicate +dedupliated,deduplicated +deecorator,decorator +deeep,deep +deelte,delete +deendencies,dependencies +deendency,dependency defacation,defamation +defail,detail +defailt,default defaint,defiant defaintly,defiantly +defalt,default defaltion,deflation +defalts,defaults +defalut,default defamating,defamation defanitely,definitely defanitly,defiantly -defauls,defaults +defargkey,defragkey +defatult,default +defaukt,default +defaul,default +defaulat,default +defaulats,defaults +defauld,default +defaulds,defaults +defaule,default +defauled,default,defaulted +defaules,defaults +defaulf,default +defaulfs,defaults +defaulg,default +defaulgs,defaults +defaulh,default +defaulhs,defaults +defauling,defaulting +defaulit,default +defaulits,defaults +defaulkt,default +defaulkts,defaults +defaull,default +defaulls,defaults +defaullt,default +defaullts,defaults +defaulr,default +defaulrs,defaults +defaulrt,default +defaulrts,defaults +defauls,defaults,default +defaulst,defaults,default +defaultet,defaulted +defauly,default +defaulys,defaults +defaulz,default,defaults +defaut,default +defautl,default +defautled,defaulted +defautling,defaulting defautls,defaults +defautlt,default +defautly,defaultly +defauts,defaults +defecit,deficit defectos,defects defectus,defects +defeine,define +defeines,defines defeintly,definitely defelct,deflect defelction,deflection +defenate,definite +defenately,definitely defendas,defends defendeers,defender defendent,defendant @@ -7013,6 +13633,10 @@ defendrs,defends defenesless,defenseless defenesman,defenseman defenisvely,defensively +defenitely,definitely +defenition,definition +defenitions,definitions +defenitly,definitely defensd,defends defensea,defenseman defenselss,defenseless @@ -7021,16 +13645,34 @@ defensese,defenseless defensie,defensive defensivley,defensively defensivly,defensively +deferal,deferral +deferals,deferrals +defered,deferred +deferentiating,differentiating +defering,deferring +deferreal,deferral defetead,defeated deffensively,defensively +deffered,differed,deferred +defference,difference,deference +defferent,different,deferent +defferential,differential,deferential +defferently,differently +deffering,differing +defferred,deferred +deffers,differs,defers deffine,define deffined,defined +deffinition,definition +deffinitively,definitively +deffirent,different defianetly,definitely defianlty,defiantly -defiantely,definitely +defiantely,definitely,defiantly defiantley,definitely defibately,definitely deficately,definitely +defice,device deficeint,deficient deficiancies,deficiencies deficiancy,deficiency @@ -7045,7 +13687,12 @@ deficienty,deficiency deficieny,deficiency deficiet,deficient deficites,deficits +defien,define +defiend,defined +defiened,defined defiintely,definitely +defin,define +definad,defined definaetly,definitely definaitly,definitely definaltey,definitely @@ -7073,7 +13720,12 @@ definatly,definitely definatrly,definitely definaty,definitely definayely,definitely +defind,defined,defund +definded,defined,defunded +defineas,defines defineatly,definitely +defineed,defined +definend,defined definet,definite definetally,definitely definetaly,definitely @@ -7085,13 +13737,19 @@ definetly,definitely definettly,definitely definety,definitely definetyl,definitely +definiation,definition definicion,definition definie,definite +definied,defined definietly,definitely +definifiton,definition definig,defining definilty,definitely definining,defining defininitely,definitively +defininition,definition +defininitions,definitions +definintion,definition definit,definite definitaley,definitely definitaly,definitely @@ -7100,13 +13758,17 @@ definitelly,definitely definitevely,definitively definitevly,definitively definiteyl,definitely +definitian,definition definitie,definitive definitiely,definitively definitieve,definitive definitifely,definitively +definitiion,definition +definitiions,definitions definitiley,definitively definitin,definitions definitinely,definitively +definitio,definition definititely,definitively definitivelly,definitively definitivley,definitively @@ -7122,52 +13784,91 @@ definitlry,definitely definitlty,definitely definitly,definitely definito,definition +definitoin,definition definiton,definition +definitons,definitions definitv,definitive definitve,definite definityl,definitely definjtely,definitely definltely,definitely definltey,definitely +definned,defined +definnition,definition definotely,definitely +defins,defines,define definstely,definitely +defint,definite,define defintaley,definitely defintaly,defiantly +definte,definite,define +defintian,definition defintiely,definitely defintiion,definitions defintily,definitely defintion,definition +defintions,definitions +defintition,definition +defintivly,definitively defintley,definitely definutely,definitely defitenly,definitely defitinly,definitely +defition,definition +defitions,definitions defitnaly,defiantly defitnely,definitely deflaction,deflection deflatin,deflation +deflaut,default defleciton,deflection deflecticon,deflection deflectin,deflection deflecto,deflection deflektion,deflection +defned,defend,defined defniately,definitely defnietly,definitely +defninition,definition +defninitions,definitions +defnitions,definitions +defore,before +defqault,default +defragmenation,defragmentation defualt,default +defualtdict,defaultdict defualts,defaults +defult,default degarde,degrade degarded,degraded degenarate,degenerate +degenarated,degenerated +degenarating,degenerating +degenaration,degeneration degenerare,degenerate degenere,degenerate degenererat,degenerate degeneret,degenerate degenerite,degenerate +degenracy,degeneracy +degenrate,degenerate +degenrated,degenerated +degenrates,degenerates +degenratet,degenerated +degenrating,degenerating +degenration,degeneration +degerate,degenerate +degeree,degree +degnerate,degenerate +degnerated,degenerated +degnerates,degenerates degoratory,derogatory degradacion,degradation degradating,degradation degradato,degradation degradead,degraded degraderad,degraded +degrads,degrades degragation,degradation degraged,degrade degrase,degrasse @@ -7175,6 +13876,14 @@ degrassie,degrasse degrassse,degrasse degrate,degrade degrated,degrade +degration,degradation +degredation,degradation +degreee,degree +degreeee,degree +degreeees,degrees +degreees,degrees +degres,degrees,digress +degress,degrees,digress degridation,degradation dehydraded,dehydrated dehyrdated,dehydrated @@ -7182,41 +13891,95 @@ dehyrdation,dehydration deifnately,definitely deifnetly,definitely deifnitly,definitely +deimiter,delimiter +deine,define +deined,denied,defined deiners,deniers +deinitailse,deinitialise +deinitailze,deinitialize deinitalization,deinitialization deinitalize,deinitialize deinitalized,deinitialized deinitalizes,deinitializes deinitalizing,deinitializing +deinstantating,deinstantiating +deintialize,deinitialize +deintialized,deinitialized +deintializing,deinitializing +deisgn,design deisgnated,designated deisgned,designed deisgner,designer deisgners,designers +deisgning,designing deisgns,designs deivant,deviant +deivce,device +deivces,devices +deivices,devices +deklaration,declaration dekstop,desktop dekstops,desktops +dektop,desktop +dektops,desktops delaership,dealership delaerships,dealerships +delagate,delegate delagates,delegates +delaloc,delalloc +delalyed,delayed delapidated,dilapidated +delaraction,declaration +delaractions,declarations +delarations,declarations +delare,declare +delared,declared +delares,declares +delaring,declaring +delate,delete +delayis,delays delcaration,declaration +delcarations,declarations delcare,declare delcared,declared delcares,declares delcaring,declaring delcining,declining +delclaration,declaration delearship,dealership delearships,dealerships +delection,detection,deletion,selection +delections,detections,deletions,selections delegatie,delegate delegaties,delegate delegative,delegate +delele,delete +delelte,delete +delemeter,delimiter +delemiter,delimiter delepted,depleted delerious,delirious +delet,delete +deletd,deleted +deleteed,deleted +deleteing,deleting +deleteion,deletion +deleteting,deleting +deletiong,deletion +delets,deletes delevopment,development +delevopp,develop delfation,deflation delfect,deflect delfection,deflection +delgate,delegate +delgated,delegated +delgates,delegates +delgating,delegating +delgation,delegation +delgations,delegations +delgator,delegator +delgators,delegators delibarate,deliberate delibaretely,deliberately deliberant,deliberate @@ -7224,16 +13987,60 @@ deliberante,deliberate deliberatley,deliberately deliberatly,deliberately deliberetly,deliberately +deliberite,deliberate +deliberitely,deliberately delibirate,deliberate delibirately,deliberately delibitating,debilitating +delibrate,deliberate +delibrately,deliberately +delievering,delivering +delievery,delivery +delievred,delivered +delievries,deliveries +delievry,delivery delightlful,delightful deligthful,delightful +delimeted,delimited +delimeter,delimiter +delimeters,delimiters +delimiited,delimited +delimiiter,delimiter +delimiiters,delimiters +delimitiaion,delimitation +delimitiaions,delimitations +delimitiation,delimitation +delimitiations,delimitations +delimitied,delimited +delimitier,delimiter +delimitiers,delimiters +delimitiing,delimiting +delimitimg,delimiting +delimition,delimitation +delimitions,delimitations +delimitis,delimits +delimititation,delimitation +delimititations,delimitations +delimitited,delimited +delimititer,delimiter +delimititers,delimiters +delimititing,delimiting +delimitor,delimiter +delimitors,delimiters +delimitted,delimited +delimma,dilemma +delimted,delimited +delimters,delimiter +delink,unlink +delivared,delivered +delivative,derivative +delivatives,derivatives deliverate,deliberate deliverately,deliberately delivere,deliveries deliverees,deliveries deliveres,delivers +delivermode,deliverymode deliverying,delivering deliverys,delivers deliviered,delivered @@ -7243,15 +14050,26 @@ delporable,deplorable delpoyed,deployed delpoying,deploying delpoyment,deployment +delte,delete +delted,deleted +deltes,deletes +delting,deleting +deltion,deletion delusionally,delusively delusionnal,delusional delutional,delusional +delvery,delivery delyaing,delaying +demaind,demand demandas,demands demandes,demands +demaned,demand,demeaned demcorats,democrats demenaor,demeanor demenor,demeanor +demension,dimension +demensional,dimensional +demensions,dimensions demenstration,demonstration demenstrations,demonstrations dementa,dementia @@ -7280,9 +14098,12 @@ democratisch,democratic democray,democracy democrazies,democracies democrocies,democracies +demodualtor,demodulator +demog,demo demograhic,demographic demograhpic,demographic demograhpics,demographics +demographical,demographic demographis,demographics demographs,demographics demograpic,demographic @@ -7291,6 +14112,7 @@ demogrpahic,demographic demogrpahics,demographics demolation,demolition demolicion,demolition +demolishon,demolition demolision,demolition demolitian,demolition demoliting,demolition @@ -7300,6 +14122,7 @@ demolution,demolition demonination,denominations demoninations,denominations demoninator,denominator +demoninators,denominators demonished,demolished demonstarte,demonstrate demonstarted,demonstrated @@ -7336,8 +14159,13 @@ demosntrates,demonstrates demosntrating,demonstrating demosntration,demonstrations demosntrations,demonstrations +demostrate,demonstrate +demostrated,demonstrated +demostrates,demonstrates +demostrating,demonstrating demostration,demonstration demsond,desmond +demudulator,demodulator denegerate,degenerate denegrating,denigrating deneirs,deniers @@ -7362,21 +14190,36 @@ denomonations,denominations denomonator,denominator denonimator,denominator denseley,densely +densitity,density densitiy,density densley,densely densly,densely +denstiy,density dentistas,dentists dentistes,dentists +deocde,decode +deocded,decoded +deocder,decoder +deocders,decoders +deocdes,decodes +deocding,decoding +deocdings,decodings deocrations,decorations deocrative,decorative +deoes,does deomcracies,democracies deomcrat,democrat deomcratic,democratic deomcrats,democrats deomgraphics,demographics deomnstration,demonstrations +deompression,decompression deopsited,deposited deovtion,devotion +depandance,dependance +depandancies,dependencies +depandancy,dependency +depandent,dependent deparment,department deparmental,departmental deparments,departments @@ -7390,29 +14233,113 @@ depciting,depicting depcition,depiction depcitions,depictions depcits,depicts +depden,depend +depdence,dependence +depdencente,dependence +depdencentes,dependences +depdences,dependences +depdencies,dependencies +depdency,dependency +depdend,depend +depdendancies,dependencies +depdendancy,dependency +depdendant,dependant +depdendants,dependants +depdended,depended +depdendence,dependence +depdendences,dependences +depdendencies,dependencies +depdendency,dependency +depdendent,dependent +depdendents,dependents +depdendet,dependent +depdendets,dependents depdending,depending +depdends,depends +depdenence,dependence +depdenences,dependences +depdenencies,dependencies +depdenency,dependency +depdenent,dependent +depdenents,dependents +depdening,depending +depdenncies,dependencies +depdenncy,dependency +depdens,depends +depdent,dependent +depdents,dependents +depecated,deprecated depection,deception depedencies,dependencies depedency,dependency +depedencys,dependencies +depedent,dependent +depeding,depending depelted,depleted depencencies,dependencies depencency,dependency +depencent,dependent +depencies,dependencies +depency,dependency dependancey,dependency dependancies,dependencies dependancy,dependency +dependancys,dependencies +dependand,dependant dependandt,dependant dependat,dependant +dependcies,dependencies +dependcy,dependency dependd,depended +dependecies,dependencies +dependecy,dependency +dependecys,dependencies +dependees,dependencies +dependeing,depending dependencey,dependency dependencias,dependencies -dependencie,dependence +dependencie,dependence,dependency +dependencied,dependency +dependenciens,dependencies +dependencis,dependencies +dependencys,dependencies +dependend,dependent,depended +dependendent,dependent dependends,depended dependened,depended dependenices,dependencies dependenies,dependencies +dependening,depending dependensies,dependencies dependenta,dependent dependente,dependence +dependeny,dependency +dependices,dependencies +dependicy,dependency +dependig,depending +dependncies,dependencies +dependncy,dependency +depened,depend +depenedecies,dependencies +depenedecy,dependency +depenedent,dependent +depenencies,dependencies +depenencis,dependencies +depenency,dependency +depenencys,dependencies +depenend,depend +depenendecies,dependencies +depenendecy,dependency +depenendence,dependence +depenendencies,dependencies +depenendency,dependency +depenendent,dependent +depenending,depending +depenent,dependent +depenently,dependently +depening,depending,deepening +depennding,depending +deperecated,deprecated deperecation,deprecation depicitng,depicting depiciton,depiction @@ -7421,17 +14348,27 @@ depictes,depicts depictin,depictions depitcs,depicts deplacements,replacements +deploied,deployed +deploiment,deployment +deploiments,deployments deplorabel,deplorable deplorabil,deplorable deplorabile,deplorable deplorible,deplorable deployd,deployed +deployement,deployment +deploymenet,deployment +deploymenets,deployments deplyoing,deploying deplyoment,deployment +depndant,dependant +depnds,depends depoisted,deposited depolyed,deployed depolying,deploying depolyment,deployment +deporarily,temporarily +deposint,deposing depositas,deposits depositd,deposited depositers,deposits @@ -7440,6 +14377,24 @@ depositis,deposits depositos,deposits depostied,deposited depostis,deposits +depracated,deprecated +depreacte,deprecate +depreacted,deprecated +depreacts,deprecates +deprecatedf,deprecated +depreceate,deprecate,depreciate +depreceated,deprecated,depreciated +depreceating,depreciating,deprecating +depreceation,depreciation,deprecation +deprectaed,deprecated +deprectat,deprecate +deprectate,deprecate +deprectated,deprecated +deprectates,deprecates +deprectating,deprecating +deprectation,deprecation +deprectats,deprecates +deprected,deprecated depresse,depressive depressie,depressive depressief,depressive @@ -7448,7 +14403,17 @@ depressieve,depressive depressin,depression depresso,depression depresssion,depression +depretiate,depreciate,deprecate +depretiated,depreciated,deprecated +depretiates,depreciates,deprecates +depretiating,depreciating,deprecating +depretiation,depreciation,deprecation +depretiats,depreciates,deprecates deprevation,deprivation +depricate,deprecate +depricated,deprecated +depricates,deprecates +depricating,deprecating deprication,deprivation deprivating,deprivation deprivaton,deprivation @@ -7459,24 +14424,73 @@ depserately,desperately depseration,desperation depsise,despise depsoited,deposited +dequed,dequeued +derageable,dirigible deragotory,derogatory -deram,dram +deram,dram,dream +derective,directive +derectory,directory +derefence,dereference +derefenced,dereferenced +derefencing,dereferencing +derefenrence,dereference +dereferencable,dereferenceable +derefernce,dereference +derefernced,dereferenced +dereferncence,dereference +dereferncencer,dereferencer +dereferncencers,dereferencers +dereferncences,dereferences +dereferncer,dereferencer +dereferncers,dereferencers +derefernces,dereferences +dereferncing,dereferencing +derefernece,dereference +derefrencable,dereferenceable +derefrence,dereference +deregistartion,deregistration +deregisted,deregistered +deregisteres,deregisters +deregistrated,deregistered +deregistred,deregistered +deregiter,deregister +deregiters,deregisters deregualtion,deregulation deregulaiton,deregulation deregulatin,deregulation +derevative,derivative +derevatives,derivatives +derfien,define +derfiend,defined +derfine,define +derfined,defined +dergeistered,deregistered +dergistration,deregistration +deriair,derriere +dericed,derived +deriffed,derived derivate,derivative derivaties,derivatives +derivatio,derivation +derivativ,derivative derivativos,derivatives +derivativs,derivatives +deriver,derive,driver deriviated,derived derivitave,derivative derivitaves,derivatives derivitive,derivative derivitives,derivatives +derivitivs,derivatives +derivtive,derivative +derivtives,derivatives dermatalogist,dermatologist dermatolagist,dermatologist dermatoligist,dermatologist dermatologyst,dermatologist dermetologist,dermatologist +dermine,determine +dermines,determines dermitologist,dermatologist derogatary,derogatory derogatery,derogatory @@ -7486,46 +14500,156 @@ derogotary,derogatory derogotory,derogatory derpatologist,dermatologist derpivation,deprivation +derprecated,deprecated +derrivatives,derivatives +derrive,derive +derrived,derived +dertermine,determine +derterming,determining +derth,dearth derugulation,deregulation derviative,derivative derviatives,derivatives +dervie,derive +dervied,derived +dervies,derives +dervived,derived +desactivate,deactivate +desactivated,deactivated +desallocate,deallocate +desallocated,deallocated +desallocates,deallocates +desaster,disaster +descallocate,deallocate +descallocated,deallocated descandants,descendants +descchedules,deschedules +desccription,description +descencing,descending descendands,descendants descendats,descendants -descendend,descended +descendend,descended,descendent,descendent descendends,descended descendenta,descendents descened,descend descentants,descendants +descentences,descendents,descendents descenting,descending descerning,descending +descibe,describe descibed,described +descibes,describes +descibing,describing +descide,decide +descided,decided +descides,decides +desciding,deciding +desciminate,discriminate,disseminate,decimate descipable,despicable +desciption,description +desciptions,descriptions +desciptor,descriptor +desciptors,descriptors descirbe,describe descirbes,describes -descirption,descriptions +desciribe,describe +desciribed,described +desciribes,describes +desciribing,describing +desciription,description +desciriptions,descriptions +descirption,descriptions,description +descirptor,descriptor descision,decision descisions,decisions +descize,disguise +descized,disguised +descktop,desktop +descktops,desktops +desconstructed,deconstructed +descover,discover +descovered,discovered +descovering,discovering +descovery,discovery descprition,descriptions +descrementing,decrementing +describ,describe +describibg,describing describiste,describes +describng,describing describtion,description describtions,descriptions descrie,describe descriibes,describes descriminant,discriminant +descriminate,discriminate +descriminated,discriminated +descriminates,discriminates +descriminating,discriminating +descriont,description +descriotor,descriptor descripcion,description +descripe,describe +descriped,described +descripes,describes +descriping,describing +descripition,description descripiton,descriptions +descripor,descriptor descripters,descriptors +descriptio,description +descriptiom,description +descriptionm,description +descriptior,descriptor +descriptiors,descriptors descriptivos,descriptions -descriptoin,descriptions +descripto,descriptor +descriptoin,descriptions,description +descriptoins,descriptions descripton,description descriptons,descriptions +descriptot,descriptor +descriptoy,descriptor +descriptuve,descriptive descrise,describes -descritpion,descriptions +descrition,description +descritpion,descriptions,description +descritpions,descriptions +descritpiton,description +descritpitons,descriptions +descritpor,descriptor +descritpors,descriptors +descritpr,descriptor +descritpro,descriptor +descritpros,descriptors +descritprs,descriptors +descritption,description +descritptions,descriptions +descritptive,descriptive +descritptor,descriptor +descritptors,descriptors descrpition,descriptions +descrption,description +descrptions,descriptions +descrptor,descriptor +descrptors,descriptors +descrutor,destructor +descrybe,describe +descrybing,describing +descryption,description +descryptions,descriptions +desctiption,description desctiptions,descriptions +desctiptor,descriptor +desctiptors,descriptors +desctop,desktop +desctructed,destructed desctruction,destruction +desctructive,destructive +desctructor,destructor descuss,discuss +descvription,description +descvriptions,descriptions desencitized,desensitized desensatized,desensitized desensitied,desensitized @@ -7536,6 +14660,10 @@ desentisized,desensitized desentitized,desensitized desentizised,desensitised desentralized,decentralized +desepears,disappears +deserailize,deserialize +deserializazion,deserialization +desgin,design desginated,designated desgination,designation desginations,destinations @@ -7545,43 +14673,84 @@ desginers,designers desgining,designing desgins,designs desgustingly,disgustingly +desiar,desire +desicate,desiccate +desicion,decision desicions,decisions desicive,decisive deside,decide +desided,decided +desides,decides +desig,design +desigern,designer desigining,designing designacion,designation designad,designated designade,designated designato,designation +designd,designed designes,designs designet,designated designstion,designation desillusioned,disillusioned +desination,destination desinations,destinations +desine,design +desing,design +desingable,designable desingage,disengage desingation,designation desinged,designed desinger,designer desingers,designers desinging,designing +desingn,design +desingned,designed +desingner,designer +desingning,designing +desingns,designs desings,designs +desintaiton,destination +desintation,destination +desintations,destinations desintegrated,disintegrated desintegration,disintegration desinterested,disinterested +desipite,despite desireable,desirable +desision,decision +desisions,decisions +desitination,destination +desition,decision +desitions,decisions desitnation,destination desitnations,destinations desitned,destined desitny,destiny +deskop,desktop +deskops,desktops desktiop,desktop desktopbsd,desktops desktopos,desktops +deskys,disguise +deslected,deselected +deslects,deselects +desltop,desktop +desltops,desktops +desne,dense desnely,densely desnity,density +desnse,dense +desogn,design +desogned,designed +desogner,designer +desogning,designing +desogns,designs +desolve,dissolve desomnd,desmond desorder,disorder desoriented,disoriented -desparate,desperate +desparate,desperate,disparate desparately,desperately desparation,desperation despciable,despicable @@ -7604,17 +14773,38 @@ despirately,desperately despiration,desperation despiste,despise despoited,deposited +desposit,deposit,deposition +desposition,disposition desqualified,disqualified desregarding,disregarding desriable,desirable +desribe,describe +desribed,described +desribes,describes +desribing,describing +desription,description +desriptions,descriptions +desriptor,descriptor +desriptors,descriptors +desrire,desire +desrired,desired +desroyer,destroyer +desscribe,describe +desscribing,describing dessertation,dissertation +dessicate,desiccate dessicated,desiccated +dessication,desiccation dessigned,designed destablized,destabilized -destiantion,destinations +destanation,destination +destiantion,destinations,destination destiantions,destinations destinaiton,destinations -destinatin,destinations +destinarion,destination +destinataion,destination +destinataions,destinations +destinatin,destinations,destination destinationhash,destinations destinato,destination destinaton,destination @@ -7622,18 +14812,34 @@ destinatons,destinations destinction,destination destinctions,destinations destiney,destiny +destinguish,distinguish destinty,destiny +destionation,destination +destionations,destinations destkop,desktop destkops,desktops +destoried,destroyed +destort,distort destory,destroy destoryed,destroyed destoryer,destroyer destoryers,destroyers destorying,destroying destorys,destroys +destoyed,destroyed destraction,destruction destractions,distractions +destrcut,destruct +destrcuted,destructed +destrcutor,destructor +destrcutors,destructors +destribute,distribute +destributed,distributed destributors,distributors +destroi,destroy +destroied,destroyed +destroing,destroying +destrois,destroys destros,destroys destrose,destroyers destroyd,destroyed @@ -7649,37 +14855,87 @@ destructivo,destruction destructo,destruction destruktion,destruction destruktive,destructive +destrutor,destructor +destrutors,destructors +destry,destroy +destryed,destroyed +destryer,destroyer +destrying,destroying +destryiong,destroying destryoed,destroyed destryoer,destroyer destryoing,destroying +destryong,destroying +destrys,destroys +destuction,destruction +destuctive,destructive +desturcted,destructed +desturtor,destructor +desturtors,destructors desuction,seduction +desychronize,desynchronize +desychronized,desynchronized +detabase,database +detachs,detaches +detahced,detached detaild,detailed detailled,detailed +detais,details detalied,detailed +detatch,detach detatched,detached +detatches,detaches +detatching,detaching +detction,detection +deteced,detected +detecing,detecting +detecs,detects,deters,detect detectarlo,detector detectaron,detector detectas,detects +detecte,detected,detect,detects +detectected,detected detectes,detects +detectetd,detected detectie,detectives +detectiona,detection detectivs,detectives detectoare,detector +detectsion,detection +detemine,determine +detemined,determined +detemines,determines +detemining,determining deteoriated,deteriorated +deterant,deterrent +deteremine,determine +deteremined,determined deteriate,deteriorate +deterimined,determined +deterine,determine deterioriating,deteriorating +determaine,determine determanism,determinism determen,determines +determenant,determinant determenation,determination determening,determining determenism,determinism +determenistic,deterministic +determimnes,determines +determin,determine determinacion,determination determinanti,determination determinare,determine determinas,determines +determinated,determined determinato,determination determinaton,determination -determinded,determine -determing,determining +determind,determined +determinded,determine,determined +determinee,determine +determineing,determining +determing,determining,determine determinging,determining determinig,determining determinining,determining @@ -7688,22 +14944,53 @@ determinisim,determinism determinisitc,deterministic determinisitic,deterministic deterministc,deterministic +deterministinc,deterministic deterministisch,deterministic deterministische,deterministic determinitic,deterministic +determinne,determine determins,determines determinsim,determinism determinsitic,deterministic determinsm,determinism +determinstic,deterministic +determinstically,deterministically +determinte,determine,determined +determintes,determines +determnine,determine +deternine,determine +detet,detect,delete +deteted,detected,deleted +detetes,deletes,detects +deteting,detecting,deleting +detetion,detection,deletion +detetmine,determine +detets,detects,deletes detials,details +detination,destination detmatologist,dermatologist detorit,detroit detramental,detrimental detremental,detrimental +detremining,determining detrimential,detrimental detrimentul,detrimental detriot,detroit +detrmine,determine +detroy,destroy +detroyed,destroyed +detroying,destroying +detroys,destroys +detructed,destructed +dettach,detach +dettaching,detaching +detur,detour +deturance,deterrence detuschland,deutschland +deubug,debug +deubuging,debugging +deug,debug +deugging,debugging deuling,dueling deustchland,deutschland deutchsland,deutschland @@ -7718,39 +15005,104 @@ devastaing,devastating devastanti,devastating devasted,devastated devasteted,devastated +devation,deviation +devce,device +devcent,decent +devcie,device develepmont,developments develepors,developers develoeprs,developers -develompent,developments +develoment,development +develoments,developments +develompent,developments,development +develompental,developmental +develompents,developments develope,develop developement,development +developements,developments developemnt,developments developmant,developmental +developme,development +developmemt,development developmenet,developments developmently,developmental developmentwise,developments developmet,developments developmetn,developments +developmetns,developments developmnet,developments developors,develops +developp,develop +developpe,develop developped,developed +developpement,development +developper,developer developpers,developers +developpment,development developres,develops developrs,develops develpment,development develpoment,developments develpoments,developments devels,delves -deveolpment,developments +deveolpment,developments,development +deveopers,developers deveploment,developments +deverloper,developer +deverlopers,developers devestated,devastated devestating,devastating devialet,deviate deviatie,deviate +devic,device +devicde,device +devicdes,devices +devicec,device +devicecoordiinates,devicecoordinates +deviceremoveable,deviceremovable +devicesr,devices +devicess,devices +devicest,devices devide,divide devided,divided +devider,divider +deviders,dividers +devides,divides +deviding,dividing +deviece,device +devied,device devilers,delivers +devined,defined +devired,derived +devirtualisaion,devirtualisation +devirtualisaiton,devirtualisation +devirtualizaion,devirtualization +devirtualizaiton,devirtualization +devirutalisation,devirtualisation +devirutalise,devirtualise +devirutalised,devirtualised +devirutalization,devirtualization +devirutalize,devirtualize +devirutalized,devirtualized +devision,division devistating,devastating +devive,device +devleop,develop +devleoped,developed +devleoper,developer +devleopers,developers +devleopper,developer +devleoppers,developers +devlop,develop +devloped,developed +devloper,developer +devlopers,developers +devloping,developing +devlopment,development +devlopments,developments +devlopper,developer +devloppers,developers +devlops,develops devlove,devolve devloved,devolved devolopement,development @@ -7759,16 +15111,41 @@ devolvendo,devolved devotin,devotion devovle,devolve devovled,devolved +devritualisation,devirtualisation +devritualization,devirtualization +devuce,device +dewrapping,unwrapping deyhdrated,dehydrated deyhdration,dehydration dezentralized,decentralized +dezert,dessert +dezibel,decibel +dezine,design +dezinens,denizens +dfine,define +dfined,defined +dfines,defines +dfinition,definition +dfinitions,definitions +dgetttext,dgettext diabetees,diabetes diabets,diabetes +diable,disable +diabled,disabled +diabler,disabler +diablers,disablers +diables,disables diablical,diabolical +diabling,disabling +diaciritc,diacritic +diaciritcs,diacritics diaganol,diagonal +diagnistic,diagnostic diagnoal,diagonal diagnoes,diagnose +diagnol,diagonal diagnosi,diagnostic +diagnosics,diagnostics diagnosied,diagnose diagnosies,diagnosis diagnositc,diagnostic @@ -7776,80 +15153,160 @@ diagnositcs,diagnostic diagnositic,diagnostic diagnossed,diagnose diagnosted,diagnose -diagnotics,diagnostic +diagnotic,diagnostic +diagnotics,diagnostic,diagnostics diagonaal,diagonal +diagonale,diagonal +diagonales,diagonals diagonse,diagnose diagonsed,diagnosed diagonsis,diagnosis diagonstic,diagnostic diagonstics,diagnostic diagramas,diagrams +diagramm,diagram diagramms,diagrams diahrrea,diarrhea +dialaog,dialog +dialate,dilate dialecs,dialects dialectes,dialects dialectos,dialects dialetcs,dialects +dialgo,dialog +dialgos,dialogs dialgoue,dialogue -dialoge,dialogue +dialig,dialog +dialigs,dialogs +dialoge,dialogue,dialog dialouge,dialogue +diamater,diameter +diamaters,diameters +diamon,diamond diamons,diamonds +diangose,diagnose +dianostic,diagnostic +diaplay,display +diaplays,displays +diappeares,disappears +diaram,diagram,diorama +diarea,diarrhea +diaresis,diaeresis +diarhea,diarrhea,diarrhea diarreah,diarrhea diarreha,diarrhea diarrheoa,diarrhea diasble,disable diasbling,disabling +diaspra,diaspora diasspointed,disappointed +diaster,disaster +diatance,distance +diatancing,distancing +dicard,discard +dicarded,discarded +dicarding,discarding +dicards,discards +dicates,dictates +dicationaries,dictionaries +dicationary,dictionary +dicergence,divergence dichomoty,dichotomy dichotomoy,dichotomy dichtomy,dichotomy +dicionaries,dictionaries +dicionary,dictionary +dicipline,discipline dicitonaries,dictionaries dicitonary,dictionary dickisch,dickish dicksih,dickish +dicline,decline +diconnected,disconnected +diconnection,disconnection diconnects,disconnects dicover,discover dicovered,discovered dicovering,discovering dicovers,discovers dicovery,discovery +dicrectory,directory +dicrete,discrete +dicretion,discretion +dicretionary,discretionary +dicsriminated,discriminated dictadorship,dictatorship +dictaionaries,dictionaries +dictaionary,dictionary dictarorship,dictatorship dictaters,dictates dictateurs,dictates dictatorhip,dictatorship dictatorshop,dictatorship dictats,dictates +dictinary,dictionary +dictioanries,dictionaries +dictioanry,dictionary dictionaire,dictionaries dictionaires,dictionaries dictionairy,dictionary dictionare,dictionaries dictionarys,dictionaries dictionay,dictionary +dictionnaries,dictionaries dictionnary,dictionary +dictoinaries,dictionaries +dictonaries,dictionaries +dictonary,dictionary dicussed,discussed +dicussions,discussions +didi,did didsapointed,disappointed -diea,idea -dieing,dying +diea,idea,die +dieing,dying,dyeing +dielectirc,dielectric +dielectircs,dielectrics +diemsion,dimension dieties,deities diety,deity difenitly,definitely diferent,different +diferently,differently diferrent,different +diffcult,difficult +diffculties,difficulties +diffculty,difficulty +diffeent,different +diffence,difference +diffenet,different +diffenrence,difference +diffenrences,differences differance,difference differances,differences +differant,different differantiate,differentiate differantiation,differentiation +differantiator,differentiator +differantion,differentiation differantly,differently +differate,differentiate +differect,different +differen,different differencial,differential differenciate,differentiate +differenciated,differentiated +differenciates,differentiates +differenciating,differentiating differenciation,differentiation differenciations,differentiation differencies,differences -differene,differences +differenct,different +differend,different +differene,differences,difference +differenes,differences differenly,differently -differens,differences -differense,differences +differens,differences,difference +differense,differences,difference differental,differential differentate,differentiate differente,difference @@ -7860,48 +15317,145 @@ differentiatiors,differentiation differentiaton,differentiation differentitation,differentiation differentl,differential +differents,different,difference differenty,differently differeny,differently +differernt,different +differes,differs +differetnt,different differientation,differentiation differintiate,differentiate +differnce,difference +differnces,differences +differnciate,differentiate +differnec,difference differnece,difference differneces,differences +differnecs,differences +differnence,difference +differnences,differences +differnencing,differencing +differnent,different +differnet,different differnetial,differential +differnetiate,differentiate +differnetiated,differentiated differnetly,differently differnt,different +differntiable,differentiable +differntial,differential +differntials,differentials +differntiate,differentiate +differntiated,differentiated +differntiates,differentiates +differntiating,differentiating +differntly,differently +differnty,different,differently +differred,differed +differrence,difference +differrent,different +difffered,differed +diffferent,different +diffferently,differently +difffers,differs +difficault,difficult +difficaulties,difficulties +difficaulty,difficulty difficulites,difficulties difficulity,difficulty difficulte,difficulties difficultes,difficulties -difficults,difficulties +difficults,difficulties,difficult difficuly,difficulty difficut,difficulty +difficutl,difficult difficutlies,difficulties difficutly,difficulty diffirentiate,differentiate +diffreences,differences +diffreent,different +diffreents,different,difference +diffrence,difference +diffrences,differences diffrent,different +diffrential,differential +diffrentiate,differentiate +diffrentiated,differentiated +diffrently,differently +diffrents,different,difference +diffrerence,difference +diffrerences,differences diffucult,difficult diffuculties,difficulties diffuculty,difficulty +diffult,difficult +diffussion,diffusion +diffussive,diffusive dificulties,difficulties dificulty,difficulty +difine,define,divine +difined,defined,divined +difines,defines,divines +difining,defining,divining +difinition,definition +difinitions,definitions +difract,diffract +difracted,diffracted +difraction,diffraction +difractive,diffractive +difuse,diffuse,defuse +difused,diffused,defused +difuses,diffuses,defused +difussion,diffusion +difussive,diffusive diganose,diagnose diganosed,diagnosed diganosis,diagnosis diganostic,diagnostic +digesty,digest +diggit,digit +diggital,digital +diggits,digits +digial,digital +digitial,digital +digitis,digits dignitiy,dignity +dignostics,diagnostics +dilema,dilemma +dilemas,dilemmas +dilineate,delineate +dillema,dilemma +dillemas,dilemmas +dillimport,dllimport dilpoma,diploma dimaond,diamond dimaonds,diamonds +dimemsions,dimensions +dimenion,dimension,dominion +dimenional,dimensional +dimenionalities,dimensionalities +dimenionality,dimensionality dimenions,dimensions +dimenionsal,dimensional +dimenionsalities,dimensionalities +dimenionsality,dimensionality +dimenison,dimension dimensinal,dimensional +dimensinoal,dimensional +dimensionaility,dimensionality dimensionals,dimensions dimensiones,dimensions dimensionnal,dimensional dimensionsal,dimensional +dimensonal,dimensional +dimenstion,dimension +dimenstions,dimensions dimention,dimension dimentional,dimensional +dimentionnal,dimensional +dimentionnals,dimensional dimentions,dimensions +dimesions,dimensions dimesnion,dimension dimesnional,dimensional dimesnions,dimensions @@ -7909,13 +15463,28 @@ dimineshes,diminishes diminisheds,diminishes diminishs,diminishes diminising,diminishing +diminsh,diminish +diminshed,diminished diminsihing,diminishing diminuitive,diminutive diminushing,diminishing +dimissed,dismissed +dimmension,dimension +dimmensioned,dimensioned +dimmensioning,dimensioning +dimmensions,dimensions +dimnension,dimension +dimnention,dimension dimunitive,diminutive +dinamic,dynamic +dinamically,dynamically +dinamicaly,dynamically +dinamiclly,dynamically +dinamicly,dynamically dinasour,dinosaur dinasours,dinosaurs dingity,dignity +dinmaic,dynamic dinosar,dinosaur dinosaures,dinosaurs dinosaurios,dinosaurs @@ -7925,12 +15494,17 @@ dinosuar,dinosaur dinosuars,dinosaurs dinsoaur,dinosaur dinsoaurs,dinosaurs +dinteractively,interactively dionsaur,dinosaur dionsaurs,dinosaurs diosese,diocese dipections,depictions diphtong,diphthong diphtongs,diphthongs +diplay,display +diplayed,displayed +diplaying,displaying +diplays,displays diplimatic,diplomatic diplomacia,diplomatic diplomancy,diplomacy @@ -7938,42 +15512,106 @@ diplomatisch,diplomatic diplomma,diploma dipolma,diploma dipolmatic,diplomatic +dipose,dispose,depose +diposed,disposed,deposed +diposing,disposing,deposing dipthong,diphthong dipthongs,diphthongs dirbble,dribble +dircet,direct +dircetories,directories +dircetory,directory +dirctly,directly +dirctories,directories +dirctory,directory +direccion,direction direccional,directional +direcctory,directory +direcctorys,directories +direcctries,directories direcitonal,directional direclty,directly +direcly,directly +direcories,directories +direcory,directory +direcotories,directories +direcotory,directory +direcotries,directories direcotry,directory +direcoty,directory +directd,directed +directely,directly +directes,directs +directgories,directories +directgory,directory directin,directions directinla,directional directionl,directional directionnal,directional directivos,directions directix,directx -directores,directors +directoies,directories +directon,direction +directores,directors,directories directorguy,directory directorios,directors -directorys,directors +directoris,directories +directort,directory +directorty,directory +directorys,directors,directories directos,directors directoty,directory directoy,directory +directpries,directories +directpry,directory +directries,directories +directrive,directive +directrives,directives +directrly,directly +directroies,directories +directrories,directories +directrory,directory directroy,directory directrx,directx +directry,directory +directsion,direction +directsions,directions directsong,directions +directtories,directories +directtory,directory directy,directly +direectly,directly +diregard,disregard direktional,directional +direrctor,director +direrctories,directories +direrctors,directors +direrctory,directory diretcx,directx +diretive,directive +diretly,directly +diretories,directories +diretory,directory +direvctory,directory dirfting,drifting dirived,derived +dirrectly,directly +dirtectory,directory +dirtyed,dirtied +dirtyness,dirtiness +dirver,driver dirvers,drivers disaapoint,disappoint disaapointed,disappointed +disabe,disable disabeld,disabled +disabeling,disabling disabels,disables +disabes,disables +disabl,disable disadvandage,disadvantaged disadvandages,disadvantaged -disadvantadge,disadvantaged +disadvantadge,disadvantaged,disadvantage disadvanteged,disadvantaged disadvanteges,disadvantages disadvantge,disadvantage @@ -7990,24 +15628,57 @@ disagreemet,disagreements disagreemtn,disagreements disagremeent,disagreements disagres,disagrees +disagress,disagrees +disalb,disable +disalbe,disable +disalbed,disabled +disalbes,disables +disale,disable +disaled,disabled disallusioned,disillusioned +disalow,disallow +disambigouate,disambiguate +disambiguaiton,disambiguation +disambiguiation,disambiguation +disapear,disappear +disapeard,disappeared disapeared,disappeared +disapearing,disappearing +disapears,disappears +disapline,discipline +disapoint,disappoint +disapointed,disappointed disapointing,disappointing +disappared,disappeared disappeard,disappeared disappearence,disappearance disappearnace,disappearance disappearnce,disappearance disappearred,disappeared disappearring,disappearing +disapper,disappear disapperaing,disappearing disapperead,disappeared disappered,disappeared +disappering,disappearing +disappers,disappears disappiont,disappoint disapporval,disapproval +disapprouval,disapproval +disapprouve,disapprove +disapprouved,disapproved +disapprouves,disapproves +disapprouving,disapproving disapprovel,disapproval disaprity,disparity disaproval,disapproval +disard,discard +disariable,desirable disaspointed,disappointed +disassebled,disassembled +disassocate,disassociate +disassocation,disassociation +disasssembler,disassembler disasterous,disastrous disastisfied,dissatisfied disastorus,disastrous @@ -8034,14 +15705,52 @@ disbaling,disabling disbeleif,disbelief disbelif,disbelief disbelife,disbelief +disble,disable +disbled,disabled discalimer,disclaimer discapline,discipline +discared,discarded +discareded,discarded +discarge,discharge +discconecct,disconnect +discconeccted,disconnected +discconeccting,disconnecting +discconecction,disconnection +discconecctions,disconnections +discconeccts,disconnects +discconect,disconnect +discconected,disconnected +discconecting,disconnecting +discconection,disconnection +discconections,disconnections +discconects,disconnects +discconeect,disconnect +discconeected,disconnected +discconeecting,disconnecting +discconeection,disconnection +discconeections,disconnections +discconeects,disconnects +discconenct,disconnect +discconencted,disconnected +discconencting,disconnecting +discconenction,disconnection +discconenctions,disconnections +discconencts,disconnects +discconet,disconnect +discconeted,disconnected +discconeting,disconnecting +discconetion,disconnection +discconetions,disconnections +discconets,disconnects +disccuss,discuss discepline,discipline disception,discretion +discernable,discernible discertation,dissertation dischard,discharged discharded,discharged -dischare,discharged +dischare,discharged,discharge +discimenation,dissemination disciniplary,disciplinary disciplanary,disciplinary disciplen,disciplines @@ -8074,19 +15783,55 @@ discograpy,discography discogrophy,discography discogrpahy,discography discolsure,disclosure +disconecct,disconnect +disconeccted,disconnected +disconeccting,disconnecting +disconecction,disconnection +disconecctions,disconnections +disconeccts,disconnects +disconect,disconnect +disconected,disconnected +disconecting,disconnecting +disconection,disconnection +disconections,disconnections +disconects,disconnects +disconeect,disconnect +disconeected,disconnected +disconeecting,disconnecting +disconeection,disconnection +disconeections,disconnections +disconeects,disconnects disconenct,disconnect disconencted,disconnected +disconencting,disconnecting +disconenction,disconnection +disconenctions,disconnections disconencts,disconnects +disconet,disconnect +disconeted,disconnected +disconeting,disconnecting +disconetion,disconnection +disconetions,disconnections +disconets,disconnects disconncet,disconnects +disconnec,disconnect +disconneced,disconnected disconnecters,disconnects disconnectes,disconnects disconnectme,disconnected disconnectus,disconnects disconnet,disconnect disconneted,disconnected +disconneting,disconnecting disconnets,disconnects disconnnect,disconnect +discontigious,discontiguous +discontigous,discontiguous +discontiguities,discontinuities discontined,discontinued +discontinous,discontinuous +discontinuos,discontinuous +discontinus,discontinue,discontinuous discontinuted,discontinued discontiued,discontinued discontiuned,discontinued @@ -8095,23 +15840,39 @@ discoruage,discourages discosure,discourse discound,discounted discountined,discontinued +discouranged,discouraged +discourarged,discouraged discources,discourse discoure,discourse discourgae,discourages discourges,discourages +discourrage,discourage +discourraged,discouraged discoved,discovered discoverd,discovered discovere,discoveries +discovereability,discoverability discoveres,discovers +discoveribility,discoverability discoveryd,discovered discoverys,discovers +discovey,discovery +discovr,discover +discovred,discovered +discovring,discovering +discovrs,discovers discrapency,discrepancy +discrards,discards discrecion,discretion discreddit,discredited discredid,discredited discreditied,discredited discreditted,discredited +discreminates,discriminates discrepany,discrepancy +discrepencies,discrepancies +discrepency,discrepancy +discrepicies,discrepancies discresion,discretion discreting,discretion discretited,discredited @@ -8134,29 +15895,53 @@ discriminatorie,discriminate discrimine,discriminate discriminitory,discriminatory discriminted,discriminated +discription,description +discriptions,descriptions discrouage,discourages discrption,discretion disctinction,distinction disctinctive,distinctive +disctinguish,distinguish disctintions,distinctions +disctionaries,dictionaries +disctionary,dictionary discualified,disqualified +discuassed,discussed +discusion,discussion discusison,discussions discussin,discussion discussiong,discussing +discusson,discussion +discussons,discussions discusssion,discussions -discusting,discussing +discusting,discussing,disgusting discustingly,disgustingly +discuusion,discussion +disdvantage,disadvantage +disection,dissection +diselect,deselect disemination,dissemination disenchanged,disenchanted +disencouraged,discouraged disengenuous,disingenuous disenginuous,disingenuous disensitized,desensitized disentry,dysentery diserable,desirable +disertation,dissertation +disfunctional,dysfunctional +disfunctionality,dysfunctionality +disgarded,discarded,discarted disgareement,disagreements disgarees,disagrees disgiuse,disguise disgiused,disguised +disgn,design +disgned,designed +disgner,designer +disgnostic,diagnostic +disgnostics,diagnostics +disgns,designs disgracful,disgraceful disgraseful,disgraceful disgrateful,disgraceful @@ -8166,6 +15951,7 @@ disgrunteld,disgruntled disgrunteled,disgruntled disgruntld,disgruntled disguisted,disguise +disguisting,disgusting disguntingly,disgustingly disgusied,disguised disguss,disgusts @@ -8180,6 +15966,7 @@ disgustose,disgusts disgustosi,disgusts disgustoso,disgusts disgustus,disgusts +disharge,discharge dishcarged,discharged dishinored,dishonored dishoner,dishonored @@ -8190,6 +15977,8 @@ disicples,disciples disicpline,discipline disicplined,disciplined disicplines,disciplines +disign,design +disignated,designated disillisioned,disillusioned disillusionned,disillusioned disillutioned,disillusioned @@ -8197,13 +15986,29 @@ disingeneous,disingenuous disingenious,disingenuous disingenuious,disingenuous disingenuos,disingenuous +disinguish,distinguish disinteresed,disinterested disintereted,disinterested disiplined,disciplined +disired,desired +diskrete,discrete +diskretion,discretion +diskretization,discretization +diskretize,discretize +diskretized,discretized diskrimination,discrimination +dislaimer,disclaimer +dislay,display +dislayed,displayed +dislaying,displaying +dislays,displays dislcaimer,disclaimer disliks,dislikes dislikse,dislikes +dislpay,display +dislpayed,displayed +dislpaying,displaying +dislpays,displays dismanlting,dismantling dismantaled,dismantled dismante,dismantle @@ -8215,25 +16020,44 @@ dismantleing,dismantling dismentled,dismantled dismisals,dismissal dismisse,dismissive +disnabled,disabled disnegage,disengage disobediance,disobedience disobediant,disobedient disobeidence,disobedience disocgraphy,discography +disokay,display disollusioned,disillusioned +disolve,dissolve disolved,dissolved +disonnect,disconnect +disonnected,disconnected disover,discover +disovering,discovering +disovery,discovery +dispached,dispatched dispacth,dispatch dispair,despair dispairty,disparity dispalcement,displacement +dispaly,display dispalyed,displayed +dispalying,displaying dispalys,displays dispapointed,disappointed disparingly,disparagingly +disparite,disparate dispartiy,disparity +dispatcgh,dispatch dispath,dispatch +dispathed,dispatched +dispathes,dispatches +dispathing,dispatching +dispay,display +dispayport,displayport +dispbibute,distribute dispecable,despicable +dispell,dispel dispencaries,dispensaries dispencary,dispensary dispence,dispense @@ -8252,22 +16076,42 @@ dispensories,dispensaries dispensory,dispensary disperportionate,disproportionate dispersa,dispensary +dispertion,dispersion dispesnary,dispensary dispicable,despicable dispite,despite +displa,display displacemnt,displacement +displacment,displacement +displacments,displacements displayd,displayed -displayes,displays +displayes,displays,displayed displayfps,displays +displayied,displayed +displayig,displaying +disply,display +displyed,displayed +displying,displaying +displys,displays +dispode,dispose disporportionate,disproportionate disporportionately,disproportionately disporportionatly,disproportionately +disporue,disparue +disposel,disposal disposicion,disposition dispositon,disposition disposle,dispose +dispossable,disposable +dispossal,disposal +disposse,dispose +dispossed,disposed,dispossessed +disposses,disposes,dispossess +dispossing,disposing disposte,dispose dispostion,disposition dispoves,dispose +dispprove,disprove,disapprove dispraportionate,disproportionate dispraportionately,disproportionately disproportianate,disproportionate @@ -8298,6 +16142,7 @@ disrecpectful,disrespectful disrecpecting,disrespecting disrection,discretion disregaring,disregarding +disregrad,disregard disrepresentation,misrepresentation disrepsect,disrespect disrepsected,disrespected @@ -8314,27 +16159,65 @@ disrespectul,disrespectful disrespekt,disrespect disrespekted,disrespected disrespekting,disrespecting +disrete,discrete +disretion,discretion +disribution,distribution disricts,districts disription,disruption disrispect,disrespect disrispectful,disrespectful disrispecting,disrespecting +disrm,disarm disrputing,disrupting disrtibution,distributions disruptin,disruption disruptivo,disruption disruptron,disruption +dissable,disable +dissabled,disabled +dissables,disables +dissabling,disabling +dissadvantage,disadvantage +dissadvantages,disadvantages dissagreement,disagreement +dissagregation,dissaggregation +dissallow,disallow +dissallowed,disallowed +dissallowing,disallowing +dissallows,disallows +dissalow,disallow +dissalowed,disallowed +dissalowing,disallowing +dissalows,disallows +dissambiguate,disambiguate +dissamble,disassemble +dissambled,disassembled +dissambler,disassembler +dissambles,disassembles +dissamblies,disassemblies +dissambling,disassembling +dissambly,disassembly +dissapate,dissipate +dissapates,dissipates dissapear,disappear dissapearance,disappearance +dissapeard,disappeared dissapeared,disappeared dissapearing,disappearing dissapears,disappears +dissaper,disappear +dissaperd,disappeared +dissapered,disappeared +dissapering,disappearing +dissapers,disappears dissapionted,disappointed dissapoimted,disappointed dissapoined,disappointed +dissapoint,disappoint dissapointd,disappointed dissapointed,disappointed +dissapointing,disappointing +dissapoints,disappoints dissapointted,disappointed dissapoited,disappointed dissapoitned,disappointed @@ -8342,23 +16225,101 @@ dissaponited,disappointed dissapoonted,disappointed dissapounted,disappointed dissappear,disappear +dissappeard,disappeared +dissappeared,disappeared +dissappearing,disappearing dissappears,disappears +dissapper,disappear +dissapperd,disappeared +dissappered,disappeared +dissappering,disappearing +dissappers,disappears dissappinted,disappointed dissappointed,disappointed dissapponted,disappointed +dissapprove,disapprove +dissapproves,disapproves dissarray,disarray +dissasemble,disassemble +dissasembled,disassembled +dissasembler,disassembler +dissasembles,disassembles +dissasemblies,disassemblies +dissasembling,disassembling +dissasembly,disassembly +dissasociate,disassociate +dissasociated,disassociated +dissasociates,disassociates +dissasociation,disassociation +dissassemble,disassemble +dissassembled,disassembled +dissassembler,disassembler +dissassembles,disassembles +dissassemblies,disassemblies +dissassembling,disassembling +dissassembly,disassembly +dissassociate,disassociate +dissassociated,disassociated +dissassociates,disassociates +dissassociating,disassociating +dissaster,disaster +dissasters,disasters dissastified,dissatisfied dissatisfed,dissatisfied dissatisifed,dissatisfied dissatsified,dissatisfied +dissble,disable +dissbled,disabled +dissbles,disables +dissbling,disabling +dissconect,disconnect +dissconnect,disconnect +dissconnected,disconnected +dissconnects,disconnects +disscover,discover +disscovered,discovered +disscovering,discovering +disscovers,discovers +disscovery,discovery +dissct,dissect +disscted,dissected +disscting,dissecting +dissctor,dissector +dissctors,dissectors +disscts,dissects +disscuesed,discussed +disscus,discuss +disscused,discussed +disscuses,discusses +disscusing,discussing disscusion,discussion disscusions,discussions +disscuss,discuss +disscussed,discussed +disscusses,discusses +disscussing,discussing +disscussion,discussion +disscussions,discussions dissepointed,disappointed dissertaion,dissertation +disshearteningly,dishearteningly +dissimiliarity,dissimilarity dissipatore,dissipate dissipointed,disappointed +dissmantle,dismantle +dissmantled,dismantled +dissmantles,dismantles +dissmantling,dismantling +dissmis,dismiss dissmisal,dismissal +dissmised,dismissed +dissmises,dismisses +dissmising,dismissing dissmisive,dismissive +dissmiss,dismiss +dissmissed,dismissed +dissmisses,dismisses +dissmissing,dismissing dissobediance,disobedience dissobediant,disobedient dissobedience,disobedience @@ -8371,19 +16332,49 @@ dissopointed,disappointed dissovle,dissolve disspaointed,disappointed disspiate,dissipate +dissplay,display dissppointed,disappointed +dissrupt,disrupt +dissrupted,disrupted +dissrupting,disrupting +dissrupts,disrupts +disssemble,disassemble +disssembled,disassembled +disssembler,disassembler +disssembles,disassembles +disssemblies,disassemblies +disssembling,disassembling +disssembly,disassembly +disssociate,dissociate +disssociated,dissociated +disssociates,dissociates +disssociating,dissociating dissspointed,disappointed +distancef,distanced,distances,distance +distantce,distance +distarct,distract distase,distaste distastful,distasteful +distater,disaster distates,distaste distatesful,distasteful distatse,distaste distatseful,distasteful +distengish,distinguish disterbance,disturbance +distibute,distribute +distibuted,distributed +distibutes,distributes +distibuting,distributing +distibution,distribution +distibutions,distributions disticnt,distinct disticntion,distinctions disticntly,distinctly distiction,distinction +distictly,distinctly +distiguish,distinguish +distiguished,distinguished distinations,distinctions distincion,distinction distinciton,distinction @@ -8406,25 +16397,46 @@ distinguise,distinguished distinguised,distinguished distinguising,distinguishing distingush,distinguish +distingushed,distinguished +distingushes,distinguishes +distingushing,distinguishing +distingusih,distinguish distingusihing,distinguishing distinktion,distinction distinquish,distinguish +distinquishable,distinguishable distinquished,distinguished distinquishing,distinguishing distint,distinct distintcly,distinctly +distintions,distinctions distirbance,disturbance -distirbuted,distribute +distirbute,distribute +distirbuted,distribute,distributed +distirbutes,distributes distirbuting,distributing distirbution,distribution distirbutions,distributions distirbutor,distributor +distirted,distorted distiungished,distinguished +distnace,distance +distnaces,distances +distnce,distance +distnces,distances +distnct,distinct +distncte,distance +distnctes,distances +distnguish,distinguish +distnguished,distinguished +distniguish,distinguish +distniguished,distinguished distoriton,distortion distorsion,distortion distortian,distortion distorto,distortion distortron,distortion +distory,destroy,distort,history distrabution,distribution distraccion,distraction distractes,distracts @@ -8436,21 +16448,32 @@ distraktion,distraction distration,distortion distrcit,district distrcits,districts +distrebuted,distributed distribitor,distributor distribitors,distributors -distribtuion,distributions +distribtion,distribution +distribtions,distributions +distribtuion,distributions,distribution +distribtuions,distributions +distribtution,distributions distribucion,distribution distribue,distributed +distribued,distributed distribuem,distribute distribuent,distribute distribuer,distribute distribuie,distribute +distribuion,distribution distribuit,distribute distribuite,distribute distribuited,distributed +distribuiting,distributing +distribuition,distribution +distribuitng,distributing distribuito,distribution distribuiton,distributions distribuitor,distributor +distribure,distribute distribusion,distributions distribustion,distributions distributie,distributed @@ -8464,28 +16487,37 @@ distributons,distributors distributore,distribute distributs,distributors distribuye,distribute +districct,district districs,districts distriubtion,distributions distrobuted,distributed distrobution,distribution distrobutions,distributions distrotion,distortion +distroying,destroying +distrub,disturb distrubance,disturbance distrubances,disturbance distrubed,disturbed distrubing,disturbing +distrubiotion,distribution +distrubite,distribute distrubited,distributed distrubiting,distributing distrubition,distribution distrubitions,distributions distrubitor,distributor distrubitors,distributors +distrubted,distributed,disrupted distrubtes,distrust +distrubtion,distribution distrubute,distribute distrubuted,distributed distrubution,distribution +distrubutions,distributions distrubutor,distributor distrubutors,distributors +distruction,destruction distructions,distractions distructive,destructive distrupts,distrust @@ -8501,53 +16533,120 @@ disturben,disturbance disturbence,disturbance disturping,disrupting distustingly,disgustingly +disuade,dissuade disucssing,discussing disucssion,discussion disucssions,discussions disupted,disputed disuptes,disputes disurption,disruption +disussion,discussion +disussions,discussions +disutils,distutils ditactorship,dictatorship +ditance,distance +ditinguishes,distinguishes +ditribute,distribute ditributed,distributed +ditribution,distribution +ditributions,distributions +divde,divide diverisfy,diversify diveristy,diversity -diversed,diverse +diversed,diverse,diverged diversifiy,diversify diversiy,diversify diverstiy,diversity +divertion,diversion +divertions,diversions +divet,divot divice,device +divicer,divider dividendes,dividends dividendos,dividends dividened,dividend divideneds,dividend dividens,dividends -divinition,divination +dividor,divider,divisor +dividors,dividers,divisors +divinition,divination,definition divinitiy,divinity divinitory,divinity divintiy,divinity +divion,division +divisable,divisible divisionals,divisions divisiones,divisions +divisior,divisor divison,division divisons,divisions +divrese,diverse +divsion,division +divsions,divisions +divsiors,divisors +dloating,floating +dnamically,dynamically +dne,done +doalog,dialog +doamin,domain,dopamine +doamine,dopamine,domain +doamins,domains doapmine,dopamine +doas,does +doble,double +dobled,doubled +dobles,doubles +dobling,doubling dobulelift,doublelift doccument,document doccumented,documented doccuments,documents +dockson,dachshund +docmenetation,documentation +docmunet,document +docmunetation,documentation +docmuneted,documented +docmuneting,documenting +docmunets,documents docrines,doctrines docrtine,doctrine docrtines,doctrines +docstatistik,docstatistic +docsund,dachshund doctines,doctrines doctirne,doctrine +doctorial,doctoral doctrins,doctrines +docucument,document +docuement,document +docuements,documents +docuemnt,document +docuemnts,documents +docuemtn,document +docuemtnation,documentation +docuemtned,documented +docuemtning,documenting +docuemtns,documents +docuent,document +docuentation,documentation docuhebag,douchebag docuhes,douches docuhey,douchey +documant,document documantaries,documentaries documantary,documentary +documantation,documentation +documants,documents +documation,documentation +documemt,document +documen,document +documenatation,documentation documenation,documentation documenatries,documentaries documenatry,documentary +documenet,document +documenetation,documentation +documenets,documents documentacion,documentation documentaion,documentation documentaire,documentaries @@ -8557,15 +16656,32 @@ documentare,documentaries documentarios,documentaries documentarse,documentaries documentarsi,documentaries +documentataion,documentation +documentataions,documentations documentaties,documentaries documentating,documentation documentato,documentation +documentaton,documentation documenteries,documentaries documentery,documentary +documentes,documents +documention,documentation documentories,documentaries documentory,documentary documentry,documentary +documetation,documentation +documetnation,documentation +documment,document +documments,documents +documnet,document +documument,document +docunment,document +doed,does +doen,done doens,does +doese,does +doesing,doing,does,dosing,dozing +doess,does dogamtic,dogmatic dogdammit,goddammit dogders,dodgers @@ -8573,17 +16689,39 @@ dogding,dodging dogfather,godfather dogmatisch,dogmatic doign,doing +doiing,doing +doiuble,double +doiubled,doubled +dokc,dock +dokced,docked +dokcer,docker +dokcerd,dockerd,docked,docker +dokcing,docking +dokcre,docker +dokcred,dockerd,docked,docker +dokcs,docks dolhpin,dolphin dolhpins,dolphins +doller,dollar +dollers,dollars +dollor,dollar +dollors,dollars dolphines,dolphins dolphinese,dolphins dolphis,dolphins +domait,domain +doman,domain +domans,domains domapine,dopamine domecracy,democracy domecrat,democrat domecrats,democrats +domension,dimension +domensions,dimensions domesitcated,domesticated domesticted,domesticated +domian,domain +domians,domains domiante,dominate domiantes,dominates domianting,dominating @@ -8601,8 +16739,17 @@ dominiant,dominant dominno,dominion dominoin,dominion domisticated,domesticated +domonstrate,demonstrate +domonstrates,demonstrates +domonstrating,demonstrating +domonstration,demonstration +donain,domain +donains,domains +donejun,dungeon +donejuns,dungeons donesticated,domesticated donig,doing +donn,done,don donwgrade,downgrade donwgraded,downgraded donwload,download @@ -8616,37 +16763,77 @@ donwvoted,downvoted donwvoters,downvoters donwvotes,downvotes donwvoting,downvoting +doocument,document doomdsay,doomsday doomsdaily,doomsday +doorjam,doorjamb doosmday,doomsday doplhin,dolphin doplhins,dolphins dopmaine,dopamine +dorce,force +dorced,forced +dorceful,forceful +dorder,order,disorder +dordered,ordered +dorment,dormant dormtund,dortmund +dorp,drop dortmud,dortmund dortumnd,dortmund +dosen,dozen,dose,doesn +dosens,dozens +dosposing,disposing dossapointed,disappointed +dosument,document +dosuments,documents +dota,data dotrmund,dortmund -doub,doubt +doub,doubt,daub +doube,double +doubel,double doubellift,doublelift +doubely,doubly +doubes,doubles doubleiift,doublelift doubleleft,doublelift doublelfit,doublelift doublelit,doublelift doublellift,doublelift +doublely,doubly doublerift,doublelift +doubletquote,doublequote doucehbag,douchebag douchely,douchey doucheus,douches +doucment,document +douible,double +douibled,doubled doulbe,double doulbelift,doublelift +doumentc,document +dout,doubt +dowgrade,downgrade +dowlink,downlink +dowlinks,downlinks +dowload,download +dowloaded,downloaded +dowloader,downloader +dowloaders,downloaders +dowloading,downloading dowloads,downloads downgarde,downgrade downgarded,downgraded -downgrated,downgrade +downgrate,downgrade +downgrated,downgrade,downgraded +downlad,download +downladed,downloaded +downlading,downloading +downlads,downloads downlaod,download downlaodable,downloadable downlaoded,downloaded +downlaodes,downloads downlaoding,downloading downlaods,downloads downloaad,download @@ -8657,13 +16844,28 @@ downloadbig,downloading downloadble,downloadable downloadeble,downloadable downloades,downloads +downloadmanger,downloadmanager downloas,downloads +downlod,download +downloded,downloaded +downloding,downloading +downlods,downloads +downlowd,download +downlowded,downloaded +downlowding,downloading +downlowds,downloads downovted,downvoted downovting,downvoting downroaded,downgraded downsiders,downsides downstar,downstairs downstaris,downstairs +downsteram,downstream +downsteramed,downstreamed +downsteramer,downstreamer +downsteramers,downstreamers +downsteraming,downstreaming +downsterams,downstreams downstiars,downstairs downtokers,downvoters downtoking,downvoting @@ -8693,54 +16895,127 @@ downvottes,downvoters downvotting,downvoting downwoters,downvoters downwoting,downvoting +dows,does +dowt,doubt +doxgen,doxygen +dpeends,depends +dpendent,dependent +dpuble,double +dpubles,doubles draclua,dracula +draconain,draconian dracual,dracula draculea,dracula draculla,dracula +dragable,draggable +draged,dragged +draging,dragging dragones,dragons dragonus,dragons +draing,drawing drakest,darkest dramaticaly,dramatically dramaticlly,dramatically +drammatic,dramatic drammatically,grammatically dramtic,dramatic +dran,drawn drankenstein,frankenstein drasitcally,drastically +drastical,drastically drasticaly,drastically drasticlly,drastically +drats,drafts draughtman,draughtsman dravadian,dravidian +draview,drawview +drawack,drawback +drawacks,drawbacks +drawed,drew,drawn +drawm,drawn +drawng,drawing dreasm,dreams +dreawn,drawn +dregee,degree +dregees,degrees +drescription,description +drescriptions,descriptions drfiting,drifting +driagram,diagram +driagrammed,diagrammed +driagramming,diagramming +driagrams,diagrams dribbel,dribble driectly,directly driectx,directx drifitng,drifting driftig,drifting drinkes,drinkers +drity,dirty +driveing,driving driveris,drivers +drivr,driver drnik,drink +dropabel,droppable +dropable,droppable +droped,dropped +droping,dropping +droppend,dropped +droppped,dropped +dropse,drops +droput,dropout drotmund,dortmund +druing,during druming,drumming drummless,drumless +drvier,driver +drwaing,drawing +drwawing,drawing +drwawings,drawings +dscrete,discrete +dscretion,discretion +dscribed,described +dsiable,disable +dsiabled,disabled +dsplays,displays +dstination,destination dsyfunction,dysfunction dsyfunctional,dysfunctional dsyphoria,dysphoria dsytopian,dystopian +dthe,the +dtoring,storing duaghter,daughter duaghters,daughters duailty,duality dualtiy,duality +dubios,dubious +dublicade,duplicate +dublicat,duplicate +dublicate,duplicate +dublicated,duplicated +dublicates,duplicates +dublication,duplication dublications,publications dubsetp,dubstep +ducment,document +ducument,document +dueing,doing,during,dueling duetschland,deutschland dulaity,duality duleing,dueling +dulicate,duplicate +dum,dumb dumbbellls,dumbbells dumbbels,dumbbells dumbfouded,dumbfounded dumbfoundeads,dumbfounded dumbfouned,dumbfounded +dummp,dump,dummy +dumplicate,duplicate +dumplicated,duplicated +dumplicates,duplicates +dumplicating,duplicating dumptser,dumpster dumspter,dumpster dunegon,dungeon @@ -8750,18 +17025,63 @@ dungeos,dungeons dungeoun,dungeon dungoen,dungeon dungoens,dungeons +duoblequote,doublequote dupicate,duplicate dupilcates,duplicates +duplacate,duplicate +duplacated,duplicated +duplacates,duplicates +duplacation,duplication +duplacte,duplicate +duplacted,duplicated +duplactes,duplicates +duplaction,duplication +duplaicate,duplicate +duplaicated,duplicated +duplaicates,duplicates +duplaication,duplication +duplate,duplicate +duplated,duplicated +duplates,duplicates +duplation,duplication +duplciate,duplicate +dupliacate,duplicate +dupliacates,duplicates +dupliace,duplicate +dupliacte,duplicate +dupliacted,duplicated +dupliactes,duplicates +dupliagte,duplicate +dupliate,duplicate +dupliated,duplicated +dupliates,duplicates +dupliating,duplicating +dupliation,duplication +dupliations,duplications duplicants,duplicates duplicas,duplicates +duplicat,duplicate duplicatas,duplicates +duplicatd,duplicated duplicats,duplicates duplicitas,duplicates duplifaces,duplicates +dupplicate,duplicate +dupplicated,duplicated +dupplicates,duplicates +dupplicating,duplicating +dupplication,duplication +dupplications,duplications durabiliy,durability durabillity,durability durabiltiy,durability +durationm,duration +durectories,directories +durectory,directory +dureing,during durig,during +durining,during +durning,during durring,during dusbtep,dubstep dusfunctional,dysfunctional @@ -8770,23 +17090,38 @@ dustification,justification duting,during dwarvens,dwarves dyamically,dynamically +dyanamically,dynamically +dyanmic,dynamic dyanmically,dynamically dyanmics,dynamics dyanmite,dynamite dyansty,dynasty dyas,dryas +dymamically,dynamically dymanically,dynamically dymanics,dynamics dymanite,dynamite +dynamc,dynamic +dynamcly,dynamincally +dynamcs,dynamics dynamicallly,dynamically dynamicaly,dynamically dynamicdns,dynamics dynamiclly,dynamically +dynamicly,dynamically dynamicpsf,dynamics dynamicus,dynamics dynamis,dynamics dynamitage,dynamite +dynamlic,dynamic +dynamlically,dynamically dynastry,dynasty +dynically,dynamically +dynmaic,dynamic +dynmaically,dynamically +dynmic,dynamic +dynmically,dynamically +dynmics,dynamics dynsaty,dynasty dypshoria,dysphoria dyregulation,deregulation @@ -8810,17 +17145,36 @@ dyspohria,dysphoria dyspotian,dystopian dystopain,dystopian dystpoian,dystopian +eabled,enabled +eacf,each +eacg,each eachohter,eachother eachotehr,eachother +eachs,each eachtoher,eachother +eactly,exactly +eagrely,eagerly eahc,each +eailier,earlier +eaiser,easier ealier,earlier +ealiest,earliest +eample,example +eamples,examples +eanable,enable +eanble,enable +earch,search,each earhtbound,earthbound earhtquakes,earthquakes earilest,earliest +earler,earlier +earliear,earlier earlies,earliest earliet,earliest +earlist,earliest +earlyer,earlier earnt,earned +earpeice,earpiece earpluggs,earplugs earplus,earplugs earthboud,earthbound @@ -8833,20 +17187,40 @@ earthquakers,earthquakes earthquaks,earthquakes earthquate,earthquake earthqukes,earthquakes +easely,easily +easer,easier,eraser +easili,easily +easiliy,easily +easilly,easily +easiy,easily +easly,easily easthetically,esthetically easthetics,esthetics eastwod,eastwood eastwoood,eastwood eastwoord,eastwood +easyer,easier eatswood,eastwood +eaturn,return,saturn +eaxct,exact +ebale,enable +ebaled,enabled +ebcidc,ebcdic ebcuase,becuase +ebedded,embedded +eccessive,excessive ecclectic,eclectic eceonomy,economy +ecept,except +eception,exception +eceptions,exceptions ecidious,deciduous ecilpse,eclipse eclipes,eclipse +eclise,eclipse eclispe,eclipse eclpise,eclipse +ecognized,recognized ecoligical,ecological ecologia,ecological ecomonic,economic @@ -8865,35 +17239,91 @@ economisesti,economists economisit,economists economisiti,economist economistes,economists +ecplicit,explicit +ecplicitly,explicitly +ecret,secret,erect +ecspecially,especially ecstacys,ecstasy ecstascy,ecstasy ecstasty,ecstasy ect,etc ectastic,ecstatic ectsasy,ecstasy +ecxept,except +ecxite,excite +ecxited,excited +ecxites,excites +ecxiting,exciting +ecxtracted,extracted edbiles,edibles +edcdic,ebcdic +edditable,editable +ede,edge edficient,deficient +ediable,editable edibels,edibles +edige,edge +ediges,edges +editedt,edited +editiing,editing editoras,editors editores,editors +editoro,editor +editt,edit +editted,edited +editter,editor +editting,editing +edittor,editor +edn,end +ednif,endif edoema,edema educacional,educational educationnal,educational +edxpected,expected eearly,early +eeeprom,eeprom +eescription,description +eevery,every +eeverything,everything +eeverywhere,everywhere +eextract,extract +eextracted,extracted +eextracting,extracting +eextraction,extraction +eextracts,extracts +efect,effect +efective,effective +efectively,effectively efel,evil +eferences,references +efetivity,effectivity +effctive,effective +effctively,effectively effeciency,efficiency effecient,efficient effeciently,efficiently effecitvely,effectively +effeck,effect +effecked,effected +effecks,effects +effeckt,effect +effectice,effective +effecticely,effectively effectionate,affectionate effectivelly,effectively effectivenss,effectiveness effectiviness,effectiveness effectivley,effectively effectivly,effectively +effectivness,effectiveness +effectly,effectively +effekt,effect +effexts,effects +efficcient,efficient efficeincy,efficiency efficeint,efficient efficeintly,efficiently +efficencty,efficiency efficency,efficiency efficent,efficient efficently,efficiently @@ -8903,20 +17333,35 @@ efficienct,efficient efficienctly,efficiency efficientcy,efficiently efficienty,efficiently -efficieny,efficiency +efficieny,efficiency,efficiently effictiveness,effectiveness -efford,effort +effiency,efficiency +effient,efficient +effiently,efficiently +efford,effort,afford effordlessly,effortlessly -effords,efforts +effords,efforts,affords effortlesly,effortlessly effortlessely,effortlessly effortlessley,effortlessly effortlessy,effortlessly effulence,effluence +eforceable,enforceable egaletarian,egalitarian egalitara,egalitarian egalitatian,egalitarian egaliterian,egalitarian +egde,edge +egdes,edges +ege,edge +egenral,general +egenralise,generalise +egenralised,generalised +egenralises,generalises +egenralize,generalize +egenralized,generalized +egenralizes,generalizes +egenrally,generally egostitical,egotistical egotastical,egotistical egotestical,egotistical @@ -8930,9 +17375,19 @@ egyptain,egyptian egyptains,egyptians egytpian,egyptian egytpians,egyptians +ehance,enhance +ehanced,enhanced +ehancement,enhancement +ehancements,enhancements +ehen,when,hen,even,then +ehenever,whenever +ehough,enough +ehr,her ehtanol,ethanol ehtereal,ethereal ehternet,ethernet +ehther,ether,either +ehthernet,ethernet ehtically,ethically ehtnically,ethnically ehtnicities,ethnicities @@ -8940,10 +17395,15 @@ ehtnicity,ethnicity eifnach,einfach eighteeen,eighteen eighten,eighteen -eigth,eighth +eighter,either +eigth,eighth,eight eigtheen,eighteen +eihter,either einfahc,einfach +einstance,instance +eisntance,instance eiter,either +eith,with eitquette,etiquette ejacluation,ejaculation ejacualte,ejaculate @@ -8957,15 +17417,19 @@ ejaculatte,ejaculate elasped,elapsed elcipse,eclipse elction,election +elctromagnetic,electromagnetic eldistribution,redistribution +eleate,relate elecrto,electro elecrtomagnetic,electromagnetic electhor,electro -electic,electric +electic,electric,eclectic +electical,electrical +electirc,electric electircal,electrical electivite,elective electivre,elective -electon,election +electon,election,electron electoraat,electorate electorale,electorate electoratul,electoral @@ -8983,14 +17447,18 @@ electricial,electrical electricien,electrician electricion,electrician electriciy,electricity +electricly,electrically electricman,electrician electricrain,electrician electrictian,electrician electricty,electricity electricy,electricity electrinic,electrician +electrinics,electronics electrisity,electricity electritian,electrician +electriv,electric +electrnoics,electronics electroal,electoral electroate,electorate electrobytes,electrolytes @@ -9022,30 +17490,63 @@ electronis,electronics electronix,election electroylte,electrolytes electroyltes,electrolytes +eleemnt,element +eleent,element +elegible,eligible elektrolytes,electrolytes +elemant,element elemantary,elementary +elemement,element +elemements,elements +elememt,element +elemen,element +elemenent,element +elemenental,elemental +elemenents,elements +elemenet,element +elemenets,elements +elemens,elements +elemenst,elements elementay,elementary +elemente,element,elements elementery,elementary elementrary,elementary elementray,elementary +elementry,elementary elementy,elementary +elemet,element +elemetal,elemental +elemetn,element +elemetns,elements +elemets,elements +eleminate,eliminate eleminated,eliminated +eleminates,eliminates eleminating,eliminating +elemnets,elements +elemnt,element +elemnts,elements +elemtary,elementary +elenment,element elepahnts,elephants elephans,elephants elephantes,elephants elephantis,elephants elephantos,elephants elephantus,elephants -eles,eels +eles,eels,else eletricity,electricity +eletromagnitic,electromagnetic +eletronic,electronic elevatin,elevation +elgible,eligible elicided,elicited eligable,eligible elimanates,eliminates elimanation,elimination elimenates,eliminates elimentary,elementary +elimiante,eliminate elimiate,eliminate elimimates,eliminates eliminacion,elimination @@ -9055,31 +17556,68 @@ eliminaste,eliminates eliminatin,elimination eliminato,elimination eliminaton,elimination +eliminetaion,elimination eliminster,eliminates +elimintate,eliminate elimintates,eliminates +eliminte,eliminate +elimnated,eliminated +elipse,ellipse,eclipse +elipses,ellipses,eclipses,ellipsis +elipsis,ellipsis,eclipses +elipsises,ellipses,ellipsis +eliptic,elliptic +eliptical,elliptical +elipticity,ellipticity elitisim,elitism elitistm,elitism +ellapsed,elapsed ellected,elected ellignton,ellington +elliminate,eliminate +elliminated,eliminated +elliminates,eliminates +elliminating,eliminating ellingotn,ellington ellipitcal,elliptical ellipitcals,elliptical ellipsical,elliptical +ellipsises,ellipsis ellipticle,elliptical +ellision,elision ellitot,elliott ellitpical,elliptical elloitt,elliott ellpitical,elliptical +elmenet,element +elmenets,elements +elment,element +elments,elements +elminate,eliminate +elminated,eliminated +elminates,eliminates +elminating,eliminating eloctrolytes,electrolytes eloquantly,eloquently eloquentely,eloquently eloquenty,eloquently eloquintly,eloquently elphant,elephant +elsef,elseif elsehwere,elsewhere +elseof,elseif +elseswhere,elsewhere +elsewehere,elsewhere +elsewere,elsewhere +elsewhwere,elsewhere +elsiof,elseif +elsof,elseif +emabaroged,embargoed +emable,enable emabrassing,embarrassing emabrgo,embargo emabssy,embassy +emailling,emailing emapthetic,empathetic emapthize,empathize emapthy,empathy @@ -9087,6 +17625,7 @@ embaraasing,embarrassing embarasaing,embarrassing embarass,embarrass embarassed,embarrassed +embarasses,embarrasses embarassig,embarrassing embarassign,embarrassing embarassimg,embarrassing @@ -9100,6 +17639,7 @@ embarrased,embarrassed embarrasement,embarrassment embarrases,embarrassed embarrasing,embarrassing +embarrasingly,embarrassingly embarrasment,embarrassment embarrasments,embarrassment embarress,embarrassed @@ -9111,29 +17651,48 @@ embarrssing,embarrassing embassay,embassy embassey,embassy embasssy,embassy +embbedded,embedded +embbeded,embedded +embdder,embedder +embdedded,embedded +embebbed,embedded +embedd,embed +embeddded,embedded +embeddeding,embedding +embedds,embeds embeded,embedded +embeed,embed emberrassing,embarrassing emberrassment,embarrassment embezelled,embezzled emblamatic,emblematic embodyment,embodiment +embold,embolden embrago,embargo +emedded,embedded +emegrency,emergency +emenet,element +emenets,elements emergancies,emergencies emergencias,emergencies emergend,emerged emergenices,emergencies emergenies,emergencies emergerd,emerged +emiited,emitted eminate,emanate eminated,emanated emipres,empires emision,emission +emiss,remiss,amiss,amass +emissed,amassed,amiss emited,emitted emiting,emitting -emition,emission +emition,emission,emotion +emlation,emulation emmediately,immediately -emmigrated,emigrated -emminent,eminent +emmigrated,emigrated,immigrated +emminent,eminent,imminent emminently,eminently emmisaries,emissaries emmisarries,emissaries @@ -9141,14 +17700,17 @@ emmisarry,emissary emmisary,emissary emmision,emission emmisions,emissions +emmit,emit emmited,emitted emmiting,emitting +emmits,emits emmitted,emitted emmitting,emitting emnity,enmity emobdiment,embodiment emotionaly,emotionally emotionella,emotionally +emoty,empty empahsize,emphasize empahsized,emphasized empahsizes,emphasizes @@ -9182,7 +17744,7 @@ emphsis,emphasis emphysyma,emphysema empiers,empires empiracally,empirically -empirial,empirical +empirial,empirical,imperial empirialism,imperialism empirialist,imperialist empiricaly,empirically @@ -9195,25 +17757,59 @@ employeur,employer employeurs,employer empolyees,employees emporer,emperor +emprically,empirically empries,empires emprisoned,imprisoned emprisonment,imprisonment +emptniess,emptiness +emptry,empty +emptyed,emptied +empy,empty +emtied,emptied +emties,empties emtpied,emptied emtpiness,emptiness emtpy,empty +emty,empty +emtying,emptying emualtion,emulation emulatin,emulation +emultor,emulator +emultors,emulators +enabe,enable +enabel,enable +enabeled,enabled +enabeling,enabling +enabing,enabling +enabledi,enabled +enableing,enabling +enablen,enabled enahnces,enhances enahncing,enhancing +enalbe,enable +enalbed,enabled +enalbes,enables enameld,enameled +enaugh,enough +enbale,enable +enbaled,enabled +enbales,enables +enbaling,enabling +enbedding,embedding +enble,enable encahnt,enchant encahnting,enchanting encalve,enclave +encapsualtes,encapsulates +encapsulatzion,encapsulation +encapsultion,encapsulation encarcerated,incarcerated encarceration,incarceration enceclopedia,encyclopedia enchamtment,enchantment -enchancement,enhancement +enchanced,enhanced +enchancement,enhancement,enchantment +enchancements,enhancements,enchantments enchancing,enchanting enchancment,enchantment enchancments,enchantments @@ -9230,9 +17826,21 @@ enchantmet,enchantments enchantmets,enchantments enchentments,enchantments enciclopedia,encyclopedia +enclosng,enclosing +enclosue,enclosure +enclosung,enclosing enclousre,enclosure enclsoure,enclosure +enclude,include +encluding,including enclycopedia,encyclopedia +encocde,encode +encocded,encoded +encocder,encoder +encocders,encoders +encocdes,encodes +encocding,encoding +encocdings,encodings encolsed,enclosed encolsure,enclosure encomapsses,encompasses @@ -9240,22 +17848,61 @@ encompase,encompass encompases,encompasses encompasess,encompasses encompesses,encompasses +enconde,encode +enconded,encoded +enconder,encoder +enconders,encoders +encondes,encodes +enconding,encoding +encondings,encodings +encorde,encode,encore +encorded,encoded +encorder,encoder +encorders,encoders +encordes,encodes,encores +encording,encoding +encordings,encodings encorporated,incorporated encorporating,incorporating -encounted,encountered +encose,enclose,encode +encosed,enclosed,encoded +encoser,encoder +encosers,encoders +encoses,encloses,encodes +encosing,enclosing,encoding +encosings,enclosings,encodings +encosure,enclosure +encounted,encountered,encounter encounterd,encountered encounteres,encounters encountred,encountered encourageing,encouraging encouraing,encouraging +encouter,encounter +encoutered,encountered +encouters,encounters +encoutner,encounter encoutnered,encountered encoutners,encounters +encouttering,encountering +encrcypt,encrypt +encripted,encrypted encription,encryption +encrpt,encrypt +encrpted,encrypted +encrption,encryption encrpyt,encrypt encrpyted,encrypted encrpytion,encryption +encrupted,encrypted +encrypiton,encryption +encrypte,encrypted,encrypt encryptiion,encryption +encryptio,encryption +encryptiong,encryption +encrytion,encryption encrytped,encrypted +encupsulates,encapsulates encyclapedia,encyclopedia encyclepedia,encyclopedia encyclopadia,encyclopedia @@ -9271,6 +17918,8 @@ encyklopedia,encyclopedia encylcopedia,encyclopedia encylopedia,encyclopedia encyplopedia,encyclopedia +encypted,encrypted +encyption,encryption encyrpt,encrypt encyrpted,encrypted encyrption,encryption @@ -9278,27 +17927,69 @@ endagnering,endangering endandering,endangering endanged,endangered endangerd,endangered +endcoded,encoded +endcoder,encoder +endcoders,encoders +endcodes,encodes +endcoding,encoding +endcodings,encodings +endding,ending +ende,end endevors,endeavors endevour,endeavour +endfi,endif +endianes,endianness +endianess,endianness +endiannes,endianness +endien,endian,indian +endiens,endians,indians endig,ending endlessley,endlessly endlessy,endlessly +endnoden,endnode endoctrinated,indoctrinated endoctrination,indoctrination +endoint,endpoint endolithes,endoliths endorcement,endorsement endorces,endorse endores,endorse endoresment,endorsement endoresments,endorsement +endpints,endpoints +endpiont,endpoint +endpionts,endpoints +endpont,endpoint endrose,endorse enduce,induce +eneables,enables +enebale,enable +enebaled,enabled +eneble,enable ened,need +enegeries,energies +enegery,energy +enehanced,enhanced enemployment,unemployment energis,energies +enery,energy +eneter,enter +enetered,entered +enetities,entities +enetity,entity +eneumeration,enumeration +eneumerations,enumerations +eneumretaion,enumeration +eneumretaions,enumerations enevlopes,envelopes +enew,new +enflamed,inflamed +enforcable,enforceable enforcees,enforces enforceing,enforcing +enforcmement,enforcement +enforcment,enforcement +enforncing,enforcing enforse,enforces enfringement,infringement engagaments,engagements @@ -9309,6 +18000,8 @@ engagment,engagement engeneer,engineer engeneering,engineering engeries,energies +engery,energy +engieer,engineer engieneer,engineer engieneers,engineers engineed,engineered @@ -9317,16 +18010,45 @@ engineerd,engineered enginer,engineer enginereed,engineered enginerring,engineering +enginge,engine +enginin,engine enginnering,engineering englsih,english +engoug,enough engrames,engrams engramms,engrams +enhabce,enhance +enhabced,enhanced +enhabces,enhances +enhabcing,enhancing +enhace,enhance +enhaced,enhanced +enhacement,enhancement +enhacements,enhancements enhacning,enhancing +enhancd,enhanced enhanceds,enhances +enhancment,enhancement +enhancments,enhancements +enhaned,enhanced enhanse,enhances +enhence,enhance +enhenced,enhanced +enhencement,enhancement +enhencements,enhancements +enhencment,enhancement +enhencments,enhancements enigneer,engineer +enironment,environment +enironments,environments +enities,entities +enitities,entities +enitity,entity enitrely,entirely +enity,entity enivitable,inevitable +enivornment,environment +enivornments,environments enivronmentally,environmentally enlargment,enlargement enlargments,enlargements @@ -9342,24 +18064,82 @@ enlightenting,enlightening enlightining,enlightening enlightned,enlightened enlightnement,enlightenment +enlightnment,enlightenment enligthen,enlighten enligthened,enlightened enligthening,enlightening enligthenment,enlightenment -enlish,english +enlish,english,enlist +enlose,enclose enlsave,enslave enlsaved,enslaved +enmpty,empty +enmum,enum +ennpoint,endpoint +enntries,entries +enocde,encode +enocded,encoded +enocder,encoder +enocders,encoders +enocdes,encodes +enocding,encoding +enocdings,encodings +enogh,enough +enoght,enough +enoguh,enough +enouch,enough +enoucnter,encounter +enoucntered,encountered +enoucntering,encountering +enoucnters,encounters +enouf,enough +enoufh,enough +enought,enough +enoughts,enough +enougth,enough +enouh,enough +enouhg,enough +enouncter,encounter +enounctered,encountered +enounctering,encountering +enouncters,encounters +enoung,enough +enoungh,enough +enounter,encounter +enountered,encountered +enountering,encountering +enounters,encounters +enouph,enough +enourage,encourage +enouraged,encouraged +enourages,encourages +enouraging,encouraging enourmous,enormous enourmously,enormously +enouth,enough +enouugh,enough +enpoint,endpoint +enpoints,endpoints +enque,enqueue +enqueing,enqueuing enrolement,enrollment enrollemnt,enrollment +enrties,entries +enrty,entry ensalve,enslave ensalved,enslaved ensconsed,ensconced entaglements,entanglements entartaining,entertaining entbook,netbook +entended,intended +entension,extension +entensions,extensions +ententries,entries +enterance,entrance enteratinment,entertainment +entereing,entering +enterily,entirely enterity,entirety enterpirse,enterprise enterpirses,enterprises @@ -9380,11 +18160,15 @@ entertainig,entertaining entertainted,entertained entertianment,entertainment entertwined,entertained +entery,entry +enteties,entities +entety,entity enthically,ethnically enthicities,ethnicities enthicity,ethnicity enthisiast,enthusiast enthisiasts,enthusiasts +enthousiasm,enthusiasm enthuasists,enthusiasts enthuiasts,enthusiast enthuisast,enthusiasts @@ -9413,14 +18197,37 @@ enthusuastic,enthusiastic entierly,entirely entierty,entirety entilted,entitled +entired,entered,entire +entireity,entirety entirelly,entirely -entirey,entirety +entires,entries +entirey,entirety,entirely +entirity,entirety entirley,entirely +entirly,entirely +entite,entire,entity +entitee,entity +entitees,entities entiteld,entitled +entites,entities +entiti,entity +entitie,entity +entitites,entities +entitities,entities entitity,entity +entitiy,entity +entitiys,entities entitlied,entitled +entitys,entities entorpy,entropy +entoties,entities +entoty,entity entoxication,intoxication +entquire,enquire,enquire +entquired,enquired,enquired +entquires,enquires,enquires +entquiries,enquiries,enquiries +entquiry,enquiry,enquiry entrepeneur,entrepreneur entrepeneurs,entrepreneurs entreperneur,entrepreneurs @@ -9448,49 +18255,122 @@ entrepreuners,entrepreneurs entretained,entertained entretaining,entertaining entretainment,entertainment +entrie,entry,entries +entriy,entry,entries entropay,entropy entrophy,entropy +entrys,entries,entry +enty,entry,entity +enulation,emulation +enumarate,enumerate +enumarated,enumerated +enumarates,enumerates +enumarating,enumerating +enumation,enumeration +enumearate,enumerate +enumearation,enumeration +enumerble,enumerable +enumertaion,enumeration +enusre,ensure +envaluation,evaluation enveloppe,envelope envelopped,envelope enveloppen,envelope enveloppes,envelope +enver,never envinroment,environments +envioment,environment +enviomental,environmental +envioments,environments +envionment,environment +envionmental,environmental +envionments,environments +enviorement,environment +envioremental,environmental +enviorements,environments +enviorenment,environment +enviorenmental,environmental +enviorenments,environments enviorment,environment enviormental,environmental enviormentally,environmentally enviorments,environments +enviornemnt,environment +enviornemntal,environmental +enviornemnts,environments enviornment,environment enviornmental,environmental enviornmentalist,environmentalist enviornmentally,environmentally enviornments,environments +envioronment,environment +envioronmental,environmental +envioronments,environments +envireonment,environment +envirionment,environment +envirnment,environment +envirnmental,environmental +envirnments,environments envirnoment,environment +envirnoments,environments +enviroiment,environment enviroment,environment enviromental,environmental enviromentalist,environmentalist enviromentally,environmentally enviroments,environments -enviromnent,environments +enviromnent,environments,environment +enviromnental,environmental +enviromnentally,environmentally +enviromnents,environments +environement,environment environemnt,environment environemntal,environmental environemntally,environmentally environemnts,environments +environent,environment +environmane,environment +environmenet,environment +environmenets,environments environmentality,environmentally environmentals,environments environmentaly,environmentally environmentl,environmentally environmently,environmental -environmet,environments +environmet,environments,environment environmetal,environmental -environmnet,environments +environmets,environments +environmnet,environments,environment +environnement,environment +environtment,environment envolutionary,evolutionary +envolved,involved +envorce,enforce +envrion,environ envrionment,environment envrionmental,environmental envrionmentally,environmentally envrionments,environments +envrions,environs +envriron,environ +envrironment,environment +envrironmental,environmental +envrironments,environments +envrirons,environs +envvironment,environment enxt,next +enyway,anyway +epecifica,especifica +epect,expect +epected,expected +epectedly,expectedly +epecting,expecting +epects,expects +ephememeral,ephemeral +ephememeris,ephemeris ephipany,epiphany epidsodes,episodes +epigramic,epigrammatic epihpany,epiphany epilepsey,epilepsy epilespy,epilepsy @@ -9503,19 +18383,40 @@ episonage,espionage epitomie,epitome epliepsy,epilepsy epliogue,epilogue +eploit,exploit +eploits,exploits +epmty,empty +epressions,expressions epscially,specially epsiode,episode epsiodes,episodes epsionage,espionage epsorts,esports epsresso,espresso +eptied,emptied +eptier,emptier +epties,empties eptiome,epitome +epty,empty +epxected,expected +epxiressions,expressions +epxlicit,explicit +eqaul,equal eqaulity,equality +eqaulizer,equalizer eqaution,equation eqautions,equations +eqivalent,equivalent +eqivalents,equivalents equailty,equality +equalibrium,equilibrium +equallity,equality +equaly,equally +equel,equal +equelibrium,equilibrium equialent,equivalent equiavlent,equivalents +equilavalent,equivalent equilavent,equivalent equilavents,equivalents equilbirium,equilibrium @@ -9527,12 +18428,17 @@ equilibrim,equilibrium equilibruim,equilibrium equilibrum,equilibrium equiped,equipped +equipmentd,equipment +equipments,equipment equippment,equipment +equiptment,equipment +equire,require,enquire,equine,esquire equitorial,equatorial equivalance,equivalence equivalant,equivalent equivalants,equivalents equivalenet,equivalents +equivalentsly,equivalently,equivalency equivalet,equivalents equivallent,equivalent equivalnce,equivalence @@ -9547,31 +18453,95 @@ equivilants,equivalents equivilence,equivalence equivilent,equivalent equivilents,equivalents +equivivalent,equivalent equivlaent,equivalents equivlalent,equivalent equivlanets,equivalents +equivlantly,equivalently equivolence,equivalence equivolent,equivalent equivolents,equivalents -erally,orally +equivqlent,equivalent +eqution,equation +equtions,equations +equvalent,equivalent +erally,orally,really +erasablocks,eraseblocks +erasuer,erasure,eraser eratic,erratic eratically,erratically eraticly,erratically -erested,arrested +erested,arrested,erected +erformance,performance +erliear,earlier +erlier,earlier +erly,early +ermergency,emergency ermington,remington +eroneous,erroneous +eror,error +erorneus,erroneous +erorneusly,erroneously +erorr,error +erorrs,errors +erors,errors +erraneously,erroneously +erro,error erroenous,erroneous erroneos,erroneous +erroneus,erroneous +erroneusly,erroneously +erronous,erroneous +erronously,erroneously +errorneous,erroneous +errorneously,erroneously +errorneus,erroneous +errornous,erroneous +errornously,erroneously +errorr,error +erros,errors +errot,error +errots,errors +errro,error +errror,error +errrors,errors +errros,errors errupted,erupted +ertoneous,erroneous +ertoneously,erroneously +ertor,error,terror +ertors,errors,terrors +ervery,every +erverything,everything +esacpe,escape +esacped,escaped +esacpes,escapes escalatie,escalate escalatin,escalation escalative,escalate escalato,escalation +escapeable,escapable +escapemant,escapement escapse,escapes +escased,escaped escavation,escalation +esccape,escape +esccaped,escaped +escpae,escape +escpaed,escaped escpaes,escapes esctasy,ecstasy esctatic,ecstatic +esecute,execute esential,essential +esentially,essentially +esge,edge +esger,edger +esgers,edgers +esges,edges +esging,edging +esiest,easiest +esists,exists esitmate,estimate esitmated,estimated esitmates,estimates @@ -9579,13 +18549,25 @@ esitmation,estimation esle,else eslewhere,elsewhere esoterisch,esoteric +espace,escape +espaced,escaped +espaces,escapes +espacially,especially +espacing,escaping +espcially,especially especailly,especially +especally,especially especialy,especially +especialyl,especially +especifically,specifically,especially +especiially,especially +espect,expect espeically,especially esperate,separate espianoge,espionage espinoage,espionage espoinage,espionage +esponding,desponding,responding esponiage,espionage esporst,esports esportes,esports @@ -9594,6 +18576,7 @@ espressino,espresso espression,espresso espressso,espresso esprots,esports +esseintially,essentially essencial,essential essencially,essentially essencials,essentials @@ -9602,6 +18585,8 @@ essensials,essentials essentail,essential essentailly,essentially essentails,essentials +essentaily,essentially +essentiall,essential,essentially essentialls,essentials essentialy,essentially essentias,essentials @@ -9609,28 +18594,58 @@ essentiels,essentials essentual,essential essentually,essentially essentuals,essentials +essentualy,essentially essesital,essential +essesitally,essentially +essesitaly,essentially +essiential,essential +esssential,essential +estabilish,establish estabilshment,establishments +estabish,establish +estabishd,established +estabished,established estabishes,establishes +estabishing,establishing establishemnt,establishments establishmet,establishments establishmnet,establishments +establishs,establishes establising,establishing +establsihed,established establsihment,establishments -estbalishment,establishments +estbalishment,establishments,establishment estiamte,estimate estiamted,estimated estiamtes,estimates estimacion,estimation +estimage,estimate +estimages,estimates estimatin,estimation estimativo,estimation estination,estimation estoeric,esoteric estonija,estonia estoniya,estonia +esy,easy +etablish,establish +etablishd,established +etablished,established +etablishing,establishing +etcp,etc +etend,extend,attend +etended,extended,attended +etender,extender,attender +etenders,extenders,attenders +etends,extends,attends +etensible,extensible +etension,extension +etensions,extensions ethcially,ethically +ethe,the etherael,ethereal etherel,ethereal +etherenet,ethernet etherent,ethernet ethicallity,ethically ethicallly,ethically @@ -9645,15 +18660,27 @@ ethnicitiy,ethnicity ethniticies,ethnicities ethniticy,ethnicity ethnocentricm,ethnocentrism -ethose,those +ethose,those,ethos +etiher,either etiquete,etiquette etmyology,etymology etrailer,retailer +etroneous,erroneous +etroneously,erroneously +etror,error,terror +etrors,errors,terrors +etsablishment,establishment +etsbalishment,establishment +etst,test +etsts,tests +etxt,text euclidian,euclidean eugencis,eugenics eugneics,eugenics euhporia,euphoria euhporic,euphoric +euivalent,equivalent +euivalents,equivalents euorpean,european euorpeans,europeans euphoira,euphoria @@ -9664,6 +18691,10 @@ euphorical,euphoria euphorisch,euphoric euphroia,euphoria euphroic,euphoric +euqivalent,equivalent +euqivalents,equivalents +euristic,heuristic +euristics,heuristics europeaners,europeans europeaness,europeans europen,european @@ -9676,46 +18707,99 @@ eurpoeans,europeans euthanaisa,euthanasia euthanazia,euthanasia euthanesia,euthanasia +evalation,evaluation evaluacion,evaluation +evaluataion,evaluation +evaluataions,evaluations evaluatiing,evaluating evaluationg,evaluating +evalueate,evaluate +evalueated,evaluated +evaluete,evaluate +evalueted,evaluated +evalulates,evaluates evalutaion,evaluation +evalutaions,evaluations +evalutate,evaluate +evalutated,evaluated +evalutates,evaluates +evalutating,evaluating +evalutation,evaluation +evalute,evaluate +evaluted,evaluated +evalutes,evaluates +evaluting,evaluating +evalution,evaluation,evolution evangalical,evangelical evangelia,evangelical evangelikal,evangelical evangers,avengers +evaulate,evaluate +evaulated,evaluated +evaulates,evaluates evaulating,evaluating evaulation,evaluation +evaulator,evaluator +evaulted,evaluated +evauluate,evaluate +evauluated,evaluated +evauluates,evaluates +evauluation,evaluation evelation,elevation +evelope,envelope,envelop evelutionary,evolutionary +evem,even,ever evengalical,evangelical evenhtually,eventually evenlopes,envelopes eventally,eventually eventaully,eventually eventially,eventually +eventuall,eventually eventualy,eventually +evenually,eventually +everage,average +everaged,averaged +everbody,everybody everets,everest +everithing,everything +everone,everyone everset,everest everthing,everything evertyime,everytime +evertything,everything everwhere,everywhere +everybodies,everybody +everyhing,everything everyoens,everyones everyonehas,everyones everyoneis,everyones everyonelse,everyones everyons,everyones everyteim,everytime +everythig,everything +everythign,everything +everythin,everything +everythings,everything everytiem,everytime everyting,everything +eveyone,everyone eveyr,every eveyrones,everyones evidencd,evidenced evidende,evidenced evidentally,evidently +evironment,environment +evironments,environments +evition,eviction evloved,evolved evloves,evolves evloving,evolving +evnet,event +evoluate,evaluate +evoluated,evaluated +evoluates,evaluates +evoluation,evaluations evolutionairy,evolutionary evolutionarilly,evolutionary evolutionarly,evolutionary @@ -9723,14 +18807,26 @@ evolutionnary,evolutionary evolveds,evolves evolveos,evolves evovled,evolved +evovler,evolver evovles,evolves evovling,evolving evreyones,everyones evreytime,everytime +evrithing,everything +evry,every +evrythign,everything +evrything,everything +evrywhere,everywhere +evyrthing,everything +ewhwer,where exacarbated,exacerbated exacberate,exacerbated exacberated,exacerbated exaclty,exactly +exacly,exactly +exactely,exactly +exacty,exactly +exacutable,executable exagerate,exaggerate exagerated,exaggerated exagerates,exaggerates @@ -9756,32 +18852,105 @@ exahust,exhaust exahusted,exhausted exahusting,exhausting exahustion,exhaustion +exameple,example +exameples,examples +examied,examined +examin,examine,examining examinated,examined examind,examined examinerad,examined +examing,examining +examinining,examining +examles,examples +examnple,example +examnples,examples +exampel,example +exampeles,examples +exampels,examples +examplee,example,examples +examplees,examples exampt,exempt +exand,expand +exansive,expansive exapansion,expansion +exapend,expand +exaple,example +exaples,examples +exapmle,example +exapmles,examples exapnds,expands +exapnsion,expansion exapnsions,expansions exapnsive,expansive exarcebated,exacerbated +exatcly,exactly +exatctly,exactly exatled,exalted exauhsted,exhausted exauhsting,exhausting exauhstion,exhaustion +exausted,exhausted excact,exact +excactly,exactly +excahcnge,exchange +excahnge,exchange excahnges,exchanges excalmation,exclamation excange,exchange +excape,escape +excapes,escapes +excat,exact +excating,exacting excatly,exactly +exccute,execute +excecise,exercise +excecised,excised,exercised +excecises,exercises +excecpt,except +excecption,exception +excecptional,exceptional +excecptions,exceptions +excect,except,expect +excectable,executable +excectables,executables +excecte,execute +excected,executed,expected +excectedly,expectedly +excectes,executes +excecting,executing +excection,exception,execution +excectional,exceptional +excections,exceptions,executions +excective,executive +excectives,executives +excector,executor +excectors,executors +excects,expects +excecutable,executable +excecutables,executables excecute,execute excecuted,executed excecutes,executes excecuting,executing excecution,execution +excecutions,executions +excecutive,executive +excecutives,executives +excecutor,executor +excecutors,executors +excecuts,executes +exced,exceed excedded,exceeded +excedding,exceeding +excede,exceed +exceded,exceeded +excedeed,exceeded +excedes,exceeds +exceding,exceeding exceedigly,exceedingly exceedinly,exceedingly +exceirpt,excerpt +exceirpts,excerpts excelent,excellent excell,excel excellance,excellence @@ -9789,27 +18958,158 @@ excellant,excellent excellenet,excellence excellenze,excellence excells,excels +excempt,exempt +excempted,exempted +excemption,exemption +excemptions,exemptions +excempts,exempts +excentric,eccentric +excentricity,eccentricity +excentuating,accentuating +exceopt,exempt +exceopted,exempted +exceopts,exempts +exceotion,exemption +exceotions,exemptions excepcional,exceptional +excepetion,exception +excepions,exceptions exceprt,excerpt -exceptin,exceptions +exceptation,expectation +exceptin,exceptions,excepting,exception,expecting,accepting +exceptins,exceptions,excepting exceptionaly,exceptionally exceptionel,exceptional exceptionnal,exceptional +exceptionss,exceptions +exceptionts,exceptions excercise,exercise +excercised,exercised +excerciser,exerciser +excercises,exercises +excercising,exercising excerise,exercise excerised,exercised excerises,exercises excerising,exercising +exces,excess +excesed,exceeded +excesive,excessive +excesively,excessively excessivley,excessively excessivly,excessively +excesss,excess +excesv,excessive +excesvly,excessively +excetion,exception +excetional,exceptional +excetions,exceptions +excetpion,exception +excetpional,exceptional +excetpions,exceptions +excetption,exception +excetptional,exceptional +excetptions,exceptions +excetra,etcetera +excetutable,executable +excetutables,executables +excetute,execute +excetuted,executed +excetutes,executes +excetuting,executing +excetution,execution +excetutions,executions +excetutive,executive +excetutives,executives +excetutor,executor +excetutors,executors +exceuctable,executable +exceuctables,executables +exceucte,execute +exceucted,executed +exceuctes,executes +exceucting,executing +exceuction,execution +exceuctions,executions +exceuctive,executive +exceuctives,executives +exceuctor,executor +exceuctors,executors +exceutable,executable +exceutables,executables +exceute,execute +exceuted,executed +exceutes,executes exceuting,executing +exceution,execution exceutioner,executioner +exceutions,executions +exceutive,executive +exceutives,executives +exceutor,executor +exceutors,executors +excewption,exception +excewptional,exceptional +excewptions,exceptions +exchage,exchange +exchaged,exchanged +exchages,exchanges +exchaging,exchanging +exchagne,exchange +exchagned,exchanged +exchagnes,exchanges +exchagnge,exchange +exchagnged,exchanged +exchagnges,exchanges +exchagnging,exchanging +exchagning,exchanging +exchanage,exchange +exchanaged,exchanged +exchanages,exchanges +exchanaging,exchanging +exchance,exchange +exchanced,exchanged +exchances,exchanges +exchanche,exchange +exchanched,exchanged +exchanches,exchanges exchanching,exchanging +exchancing,exchanging +exchane,exchange +exchaned,exchanged +exchanes,exchanges +exchangable,exchangeable exchangees,exchanges +exchaning,exchanging +exchaust,exhaust +exchausted,exhausted +exchausting,exhausting +exchaustive,exhaustive +exchausts,exhausts +exchenge,exchange +exchenged,exchanged +exchenges,exchanges +exchenging,exchanging +exchnage,exchange +exchnaged,exchanged exchnages,exchanges +exchnaging,exchanging +exchng,exchange +exchngd,exchanged +exchnge,exchange +exchnged,exchanged +exchnges,exchanges +exchnging,exchanging +exchngng,exchanging +exchngs,exchanges +exciation,excitation +excist,exist excisted,existed +excisting,existing excitiment,excitement +excitment,excitement exclamacion,exclamation +exclamantion,exclamation exclamating,exclamation exclamativo,exclamation exclemation,exclamation @@ -9817,9 +19117,12 @@ exclimation,exclamation exclsuive,exclusive exclsuives,exclusives exclucivity,exclusivity +excludde,exclude excludeds,excludes -excluse,excludes +excludind,excluding +excluse,excludes,exclude,excuse,exclusive exclusie,exclusives +exclusiv,exclusive exclusivas,exclusives exclusiveity,exclusivity exclusivelly,exclusively @@ -9832,15 +19135,33 @@ exclusivos,exclusives exclusivs,exclusives exclusivty,exclusivity exclusivy,exclusivity +excluslvely,exclusively exclussive,exclusives +exclusuive,exclusive +exclusuively,exclusively +exclusuives,exclusives exclusvies,exclusives excorciating,excruciating +excpect,expect +excpected,expected +excpecting,expecting +excpects,expects +excpeption,exception +excpet,except excpetion,exception excpetional,exceptional excpetionally,exceptionally excpetions,exceptions +excplicit,explicit +excplicitly,explicitly +excplict,explicit +excplictly,explicitly +excract,extract excrept,excerpt excrusiating,excruciating +exctacted,extracted +exctract,extract +exctracted,extracted exculde,exclude exculded,excluded exculdes,excludes @@ -9852,14 +19173,31 @@ exculsives,exclusives exculsivity,exclusivity exculsivly,exclusively excurciating,excruciating +excutable,executable +excutables,executables +excute,execute +excuted,executed +excutes,executes +excuting,executing +excution,execution +execeed,exceed +execeeded,exceeded +execeeds,exceeds +exeception,exception +execeptions,exceptions execising,exercising execitioner,executioner execption,exception execptional,exceptional execptions,exceptions +exectable,executable +exected,executed,expected +execting,executing,expecting exection,execution +exections,executions exectuable,executable -exectuables,executable +exectuableness,executableness +exectuables,executable,executables exectued,executed exectuing,executing exectuion,execution @@ -9868,11 +19206,98 @@ exectuioners,executioner exectuions,executions exectuive,executive exectuives,executives +exectution,execution +exectutions,executions +execuable,executable +execuables,executables +execuatable,executable +execuatables,executables +execuatble,executable +execuatbles,executables +execuate,execute +execuated,executed +execuates,executes +execuation,execution +execuations,executions +execubale,executable +execubales,executables +execucte,execute +execucted,executed +execuctes,executes +execuction,execution +execuctions,executions +execuctor,executor +execuctors,executors +execude,execute +execuded,executed +execudes,executes +execuding,executing,excluding +execue,execute +execued,executed +execues,executes +execuet,execute +execuetable,executable +execuetd,executed +execuete,execute +execueted,executed +execuetes,executes +execuets,executes +execuing,executing +execuion,execution +execuions,executions +execuitable,executable +execuitables,executables +execuite,execute +execuited,executed +execuites,executes +execuiting,executing +execuition,execution +execuitions,executions +execulatble,executable +execulatbles,executables +execultable,executable +execultables,executables +execulusive,exclusive +execune,execute +execuned,executed +execunes,executes +execurable,executable +execurables,executables +execure,execute +execured,executed +execures,executes +execuse,excuse,execute +execused,excused,executed +execuses,excuses,executes +execusion,execution execusions,executions +execusive,exclusive +execustion,execution +execustions,executions +execut,execute +executabable,executable +executabables,executables executabe,executable +executabel,executable +executabels,executables +executabes,executables executabil,executable +executablble,executable +executabnle,executable +executabnles,executables +executation,execution +executations,executions +executbale,executable +executbales,executables +executble,executable +executbles,executables +executd,executed +executding,executing +executeable,executable +executeables,executables executible,executable executie,executive +executign,executing executin,execution executiner,executioner executings,executions @@ -9881,28 +19306,82 @@ executioneer,executioner executioneers,executioner executionees,executions executioness,executions +executiong,execution,executing executionier,executioner executionner,executioner executionor,executioner executivas,executives +executng,executing +executre,execute +executred,executed +executres,executes +executs,executes +executting,executing +executtion,execution +executtions,executions +executuable,executable +executuables,executables +executuble,executable +executubles,executables +executue,execute +executued,executed +executues,executes +executuing,executing +executuion,execution +executuions,executions +executung,executing +executuon,execution +executuons,executions +executute,execute +execututed,executed +execututes,executes +executution,execution +execututions,executions +exeed,exceed +exeeding,exceeding exeedingly,exceedingly +exeeds,exceeds exeggerating,exaggerating exeggeration,exaggeration exelent,excellent exellent,excellent +exempel,example +exempels,examples exemple,example +exemples,examples +exended,extended +exension,extension +exensions,extensions +exent,extent +exentended,extended +exepect,expect +exepectation,expectation +exepectations,expectations +exepected,expected +exepectedly,expectedly +exepecting,expecting +exepects,expects exepmtion,exemption exepmtions,exemptions -exept,except +exepriment,experiment +exeprimental,experimental +exept,except,exempt +exeption,exception,exemption exeptional,exceptional +exeptions,exceptions +exeqution,execution exerbate,exacerbate exerbated,exacerbated exercices,exercise exercicing,exercising exercide,exercised exercies,exercise -exerciese,exercises +exerciese,exercises,exercise +exerciesed,exercised +exercieses,exercises +exerciesing,exercising exerciseing,exercising +exercize,exercise exercizes,exercise exercizing,exercising exerpt,excerpt @@ -9912,44 +19391,76 @@ exersices,exercises exersicing,exercising exersising,exercising exersize,exercise +exersizes,exercises exersizing,exercising exerternal,external +exeucte,execute +exeucted,executed +exeuctes,executes exeuctioner,executioner exeuctions,executions +exeution,execution +exexutable,executable exhalted,exalted +exhange,exchange +exhanged,exchanged +exhanges,exchanges +exhanging,exchanging exhasut,exhaust exhasuted,exhausted exhasuting,exhausting exhasution,exhaustion +exhaused,exhausted exhaustin,exhaustion exhaustivo,exhaustion exhaustn,exhaustion exhausto,exhaustion +exhautivity,exhaustivity +exhcuast,exhaust +exhcuasted,exhausted exhibicion,exhibition exhibites,exhibits exhibitin,exhibition exhibitons,exhibits exhibtion,exhibition +exhist,exist +exhistance,existence +exhisted,existed +exhistence,existence +exhisting,existing +exhists,exists exhuast,exhaust exhuasted,exhausted exhuasting,exhausting exhuastion,exhaustion +exhustiveness,exhaustiveness exibition,exhibition exibitions,exhibitions exictement,excitement exicting,exciting exinct,extinct exipration,expiration +exipre,expire +exipred,expired +exipres,expires exising,existing +exisit,exist +exisited,existed +exisitent,existent +exisiting,existing exisitng,existing +exisits,exists existance,existence existane,existence existant,existent existantes,existent existantial,existential +existatus,exitstatus +existencd,existence existencial,existential existend,existed existenial,existential +existense,existence existensial,existential existenta,existential existental,existential @@ -9958,6 +19469,17 @@ existentiella,existential existet,existent existince,existence existnace,existence +existng,existing +existsing,existing +existung,existing +existy,exist +existying,existing +exitation,excitation +exitations,excitations +exite,exit,excite,exits +exixst,exist +exixt,exist +exlamation,exclamation exlated,exalted exlcamation,exclamation exlcude,exclude @@ -9969,20 +19491,46 @@ exlcusive,exclusive exlcusively,exclusively exlcusives,exclusives exlcusivity,exclusivity +exlicit,explicit +exlicite,explicit +exlicitely,explicitly +exlicitly,explicitly exliled,exiled exlpoding,exploding +exlpoit,exploit +exlpoited,exploited +exlpoits,exploits exlporer,explorer exlporers,explorers exlposion,explosion -exludes,excludes +exlude,exclude,exude +exluded,excluded,exuded +exludes,excludes,exudes +exluding,excluding,exuding +exlusion,exclusion +exlusionary,exclusionary +exlusions,exclusions +exlusive,exclusive +exlusively,exclusively +exmaine,examine +exmained,examined +exmaines,examines exmaple,example +exmaples,examples +exmple,example +exmport,export +exntry,entry exoitcs,exotics +exolicit,explicit +exolicitly,explicitly exonorate,exonerate exorbatant,exorbitant exorbatent,exorbitant exorbidant,exorbitant exorbirant,exorbitant exorbitent,exorbitant +exort,export +exorted,exported,extorted,exerted exoskelaton,exoskeleton exoticas,exotics exoticos,exotics @@ -9990,23 +19538,43 @@ expalin,explain expalined,explained expalining,explaining expalins,explains +expanation,explanation,expansion +expanations,explanations,expansions expandas,expands expandes,expands +expaning,expanding +expanion,expansion +expanions,expansions expanisons,expansions expanisve,expansive +expanshion,expansion +expanshions,expansions expansie,expansive expansiones,expansions expansivos,expansions -expanssion,expansions +expanssion,expansions,expansion expantions,expansions +exparation,expiration +expasion,expansion expatriot,expatriate +expception,exception +expct,expect +expcted,expected +expctedly,expectedly +expcting,expecting expeced,expected +expeceted,expected expecially,especially expectaion,expectation +expectaions,expectations expectansy,expectancy expectantcy,expectancy expectany,expectancy expectating,expectation +expectatoins,expectations +expectatons,expectations +expectd,expected +expecte,expected expectency,expectancy expectes,expects expection,exception @@ -10019,11 +19587,66 @@ expedicion,expedition expeditivo,expedition expedito,expedition expeditonary,expeditionary +expeect,expect +expeected,expected +expeectedly,expectedly +expeecting,expecting +expeects,expects +expeense,expense +expeenses,expenses +expeensive,expensive +expeience,experience +expeienced,experienced +expeiences,experiences +expeiencing,experiencing +expeiment,experiment +expeimental,experimental +expeimentally,experimentally +expeimentation,experimentation +expeimentations,experimentations +expeimented,experimented +expeimentel,experimental +expeimentelly,experimentally +expeimenter,experimenter +expeimenters,experimenters +expeimenting,experimenting expeiments,experiments +expeiriment,experiment +expeirimental,experimental +expeirimentally,experimentally +expeirimentation,experimentation +expeirimentations,experimentations +expeirimented,experimented +expeirimentel,experimental +expeirimentelly,experimentally +expeirimenter,experimenter +expeirimenters,experimenters +expeirimenting,experimenting +expeiriments,experiments expell,expel expells,expels +expement,experiment +expemental,experimental +expementally,experimentally +expementation,experimentation +expementations,experimentations +expemented,experimented +expementel,experimental +expementelly,experimentally +expementer,experimenter +expementers,experimenters +expementing,experimenting +expements,experiments +expemplar,exemplar +expemplars,exemplars +expemplary,exemplary +expempt,exempt +expempted,exempted +expemt,exempt +expemted,exempted expemtion,exemption expemtions,exemptions +expemts,exempts expences,expense expendature,expenditure expendatures,expenditures @@ -10037,22 +19660,81 @@ expensve,expense expentancy,expectancy expentiture,expenditure expentitures,expenditures +expepect,expect +expepected,expected +expepectedly,expectedly +expepecting,expecting +expepects,expects +expept,expect,except +expepted,expected +expeptedly,expectedly +expepting,expecting +expeption,exception +expeptions,exceptions +expepts,expects +experament,experiment experamental,experimental +experamentally,experimentally +experamentation,experimentation +experamentations,experimentations +experamented,experimented +experamentel,experimental +experamentelly,experimentally +experamenter,experimenter +experamenters,experimenters +experamenting,experimenting +experaments,experiments +experation,expiration +experct,expect,excerpt +expercted,expected,excerpted +expercting,expecting +expercts,expects expereince,experience expereinced,experienced expereinces,experiences expereincing,experiencing experement,experiment experemental,experimental +experementally,experimentally experementation,experimentation +experementations,experimentations +experemented,experimented +experementel,experimental +experementelly,experimentally +experementer,experimenter +experementers,experimenters experementing,experimenting experements,experiments +experence,experience +experenced,experienced +experences,experiences +experencing,experiencing +experes,express +experesed,expressed +experesion,expression +experesions,expressions +experess,express +experessed,expressed +experesses,expresses +experessing,expressing +experession,expression +experessions,expressions experiance,experience experianced,experienced experiances,experiences +experiancial,experiential experiancing,experiencing +experiansial,experiential +experiantial,experiential +experiation,expiration +experiations,expirations +experice,experience +expericed,experienced +experices,experiences +expericing,experiencing experieced,experienced experieces,experiences +experiement,experiment experiemnt,experiment experiemntal,experimental experiemnted,experimented @@ -10061,49 +19743,432 @@ experienceing,experiencing experiened,experienced experiening,experiencing experiense,experiences +experienshial,experiential +experiensial,experiential +experies,expires +experim,experiment +experimal,experimental +experimally,experimentally +experimanent,experiment +experimanental,experimental +experimanentally,experimentally +experimanentation,experimentation +experimanentations,experimentations +experimanented,experimented +experimanentel,experimental +experimanentelly,experimentally +experimanenter,experimenter +experimanenters,experimenters +experimanenting,experimenting +experimanents,experiments +experimanet,experiment +experimanetal,experimental +experimanetally,experimentally +experimanetation,experimentation +experimanetations,experimentations +experimaneted,experimented +experimanetel,experimental +experimanetelly,experimentally +experimaneter,experimenter +experimaneters,experimenters +experimaneting,experimenting +experimanets,experiments +experimant,experiment experimantal,experimental +experimantally,experimentally experimantation,experimentation +experimantations,experimentations +experimanted,experimented +experimantel,experimental +experimantelly,experimentally +experimanter,experimenter +experimanters,experimenters +experimanting,experimenting +experimants,experiments +experimation,experimentation +experimations,experimentations +experimdnt,experiment +experimdntal,experimental +experimdntally,experimentally +experimdntation,experimentation +experimdntations,experimentations +experimdnted,experimented +experimdntel,experimental +experimdntelly,experimentally +experimdnter,experimenter +experimdnters,experimenters +experimdnting,experimenting +experimdnts,experiments +experimed,experimented +experimel,experimental +experimelly,experimentally +experimen,experiment +experimenal,experimental +experimenally,experimentally +experimenat,experiment +experimenatal,experimental +experimenatally,experimentally +experimenatation,experimentation +experimenatations,experimentations +experimenated,experimented +experimenatel,experimental +experimenatelly,experimentally +experimenater,experimenter +experimenaters,experimenters +experimenating,experimenting +experimenation,experimentation +experimenations,experimentations +experimenats,experiments +experimened,experimented +experimenel,experimental +experimenelly,experimentally +experimener,experimenter +experimeners,experimenters +experimening,experimenting +experimens,experiments +experimentaal,experimental +experimentaally,experimentally +experimentaat,experiment +experimentaatl,experimental +experimentaatlly,experimentally +experimentaats,experiments experimentacion,experimentation +experimentaed,experimented +experimentaer,experimenter +experimentaing,experimenting experimentaion,experimentation +experimentaions,experimentations experimentais,experiments +experimentait,experiment +experimentaital,experimental +experimentaitally,experimentally +experimentaited,experimented +experimentaiter,experimenter +experimentaiters,experimenters +experimentaitng,experimenting +experimentaiton,experimentation +experimentaitons,experimentations experimentan,experimentation -experimentating,experimentation +experimentat,experimental +experimentatal,experimental +experimentatally,experimentally +experimentatation,experimentation +experimentatations,experimentations +experimentated,experimented +experimentater,experimenter +experimentatin,experimentation,experimenting +experimentating,experimentation,experimenting +experimentatl,experimental +experimentatlly,experimentally +experimentatly,experimentally +experimentel,experimental experimentella,experimental +experimentelly,experimentally experimenterade,experimented experimentes,experiments experimention,experimenting experimentle,experimented experimentors,experiments experimentos,experiments +experimentt,experiment +experimentted,experimented +experimentter,experimenter +experimentters,experimenters +experimentts,experiments experimentul,experimental -experimet,experiments +experimer,experimenter +experimers,experimenters +experimet,experiments,experiment experimetal,experimental +experimetally,experimentally +experimetation,experimentation +experimetations,experimentations experimeted,experimented +experimetel,experimental +experimetelly,experimentally +experimetent,experiment +experimetental,experimental +experimetentally,experimentally +experimetentation,experimentation +experimetentations,experimentations +experimetented,experimented +experimetentel,experimental +experimetentelly,experimentally +experimetenter,experimenter +experimetenters,experimenters +experimetenting,experimenting +experimetents,experiments +experimeter,experimenter +experimeters,experimenters +experimeting,experimenting +experimetn,experiment +experimetnal,experimental +experimetnally,experimentally +experimetnation,experimentation +experimetnations,experimentations +experimetned,experimented +experimetnel,experimental +experimetnelly,experimentally +experimetner,experimenter +experimetners,experimenters +experimetning,experimenting +experimetns,experiments +experimets,experiments +experiming,experimenting +experimint,experiment +experimintal,experimental +experimintally,experimentally experimintation,experimentation -expermient,experiments +experimintations,experimentations +experiminted,experimented +experimintel,experimental +experimintelly,experimentally +experiminter,experimenter +experiminters,experimenters +experiminting,experimenting +experimints,experiments +experimment,experiment +experimmental,experimental +experimmentally,experimentally +experimmentation,experimentation +experimmentations,experimentations +experimmented,experimented +experimmentel,experimental +experimmentelly,experimentally +experimmenter,experimenter +experimmenters,experimenters +experimmenting,experimenting +experimments,experiments +experimnet,experiment +experimnetal,experimental +experimnetally,experimentally +experimnetation,experimentation +experimnetations,experimentations +experimneted,experimented +experimnetel,experimental +experimnetelly,experimentally +experimneter,experimenter +experimneters,experimenters +experimneting,experimenting +experimnets,experiments +experimnt,experiment +experimntal,experimental +experimntally,experimentally +experimntation,experimentation +experimntations,experimentations +experimnted,experimented +experimntel,experimental +experimntelly,experimentally +experimnter,experimenter +experimnters,experimenters +experimnting,experimenting +experimnts,experiments +experims,experiments +experimten,experiment +experimtenal,experimental +experimtenally,experimentally +experimtenation,experimentation +experimtenations,experimentations +experimtened,experimented +experimtenel,experimental +experimtenelly,experimentally +experimtener,experimenter +experimteners,experimenters +experimtening,experimenting +experimtens,experiments +experinece,experience +experineced,experienced +experinement,experiment +experinemental,experimental +experinementally,experimentally +experinementation,experimentation +experinementations,experimentations +experinemented,experimented +experinementel,experimental +experinementelly,experimentally +experinementer,experimenter +experinementers,experimenters +experinementing,experimenting +experinements,experiments +experiration,expiration +experirations,expirations +expermenet,experiment +expermenetal,experimental +expermenetally,experimentally +expermenetation,experimentation +expermenetations,experimentations +expermeneted,experimented +expermenetel,experimental +expermenetelly,experimentally +expermeneter,experimenter +expermeneters,experimenters +expermeneting,experimenting +expermenets,experiments +experment,experiment +expermental,experimental +expermentally,experimentally +expermentation,experimentation +expermentations,experimentations +expermented,experimented +expermentel,experimental +expermentelly,experimentally +expermenter,experimenter +expermenters,experimenters +expermenting,experimenting +experments,experiments +expermient,experiments,experiment +expermiental,experimental +expermientally,experimentally +expermientation,experimentation +expermientations,experimentations +expermiented,experimented +expermientel,experimental +expermientelly,experimentally +expermienter,experimenter +expermienters,experimenters +expermienting,experimenting +expermients,experiments +expermiment,experiment +expermimental,experimental +expermimentally,experimentally +expermimentation,experimentation +expermimentations,experimentations +expermimented,experimented +expermimentel,experimental +expermimentelly,experimentally +expermimenter,experimenter +expermimenters,experimenters +expermimenting,experimenting +expermiments,experiments +experminent,experiment +experminental,experimental +experminentally,experimentally +experminentation,experimentation +experminentations,experimentations +experminents,experiments +expernal,external +expers,express +experse,expense,express +expersed,expressed +experses,expenses,expresses +expersing,expressing +expersion,expression +expersions,expressions +expersive,expensive +experss,express +experssed,expressed +expersses,expresses +experssing,expressing experssion,expression experssions,expressions expertas,experts expertis,experts expertos,experts +expese,expense +expeses,expenses +expesive,expensive +expesnce,expense +expesnces,expenses +expesncive,expensive +expess,express +expessed,expressed +expesses,expresses +expessing,expressing +expession,expression +expessions,expressions +expest,expect +expested,expected +expestedly,expectedly +expesting,expecting +expet,expect,expat +expetancy,expectancy +expetation,expectation +expetc,expect +expetced,expected +expetcedly,expectedly +expetcing,expecting +expetcs,expects +expetct,expect +expetcted,expected +expetctedly,expectedly +expetcting,expecting +expetcts,expects +expetect,expect +expetected,expected +expetectedly,expectedly +expetecting,expecting +expetectly,expectedly +expetects,expects +expeted,expected +expetedly,expectedly +expetiment,experiment +expetimental,experimental +expetimentally,experimentally +expetimentation,experimentation +expetimentations,experimentations +expetimented,experimented +expetimentel,experimental +expetimentelly,experimentally +expetimenter,experimenter +expetimenters,experimenters +expetimenting,experimenting +expetiments,experiments +expeting,expecting +expets,expects +expewriment,experiment +expewrimental,experimental +expewrimentally,experimentally +expewrimentation,experimentation +expewrimentations,experimentations +expewrimented,experimented +expewrimentel,experimental +expewrimentelly,experimentally +expewrimenter,experimenter +expewrimenters,experimenters +expewrimenting,experimenting +expewriments,experiments +expexct,expect +expexcted,expected +expexctedly,expectedly +expexcting,expecting +expexcts,expects +expexnasion,expansion +expexnasions,expansions +expext,expect expextancy,expectancy +expexted,expected +expextedly,expectedly +expexting,expecting +expexts,expects +expicit,explicit +expicitly,explicitly expidentures,expenditures expidetion,expedition +expidition,expedition expiditions,expeditions expierence,experience expierenced,experienced expierences,experiences expierencing,experiencing +expierience,experience +expieriences,experiences expiers,expires +expilicitely,explicitly expination,expiration expireds,expires +expireitme,expiretime expirement,experiment expiremental,experimental expirementation,experimentation expiremented,experimented expirementing,experimenting expirements,experiments +expirience,experience +expiriences,experiences +expirimental,experimental explaination,explanation +explainations,explanations +explainatory,explanatory explaind,explained explaines,explains explaing,explaining @@ -10117,21 +20182,36 @@ explanetory,explanatory explaning,explaining explanitary,explanatory explanotory,explanatory +explantion,explanation +explantions,explanations +explcit,explicit +explecit,explicit +explecitely,explicitly +explecitily,explicitly +explecitly,explicitly explenation,explanation explenations,explanations explenatory,explanatory +explicat,explicate explicatia,explicit explicatie,explicit explicatif,explicit explicatii,explicit explicetly,explicitly expliciet,explicit +explicilt,explicit explicilty,explicitly +explicite,explicit,explicitly +explicited,explicit,explicitly +explicitelly,explicitly explicitely,explicitly explicitily,explicitly explicity,explicitly explict,explicit +explictely,explicitly +explictily,explicitly explictly,explicitly +explicty,explicitly,explicit explination,explanation explinatory,explanatory expliot,exploit @@ -10139,6 +20219,11 @@ expliotation,exploitation explioted,exploited explioting,exploiting expliots,exploits +explit,explicit +explitit,explicit +explitly,explicitly +explizit,explicit +explizitly,explicitly explodeds,explodes explodie,explode explods,explodes @@ -10149,7 +20234,8 @@ exploitaiton,exploitation exploitatie,exploitative exploitating,exploitation exploites,exploits -exploition,exploiting +exploition,exploiting,explosion,exploitation,exploit +exploitions,explosions,exploitations,exploits exploititive,exploitative explonation,exploration exploracion,exploration @@ -10167,17 +20253,29 @@ explosivas,explosives explossion,explosions explossive,explosives explosvies,explosives +explot,exploit,explore explotacion,exploration +explotation,exploitation,exploration exploted,explode explotiation,exploitation explotiative,exploitative explotied,exploited +exploting,exploiting,exploring explotions,explosions explusions,explosions expoch,epoch expodential,exponential expodentially,exponentially expodition,exposition +expoed,exposed +expoential,exponential +expoentially,exponentially +expoert,export,expert +expoerted,exported +expoit,exploit +expoitation,exploitation +expoited,exploited +expoits,exploits expolde,explode expoldes,explodes expolding,exploding @@ -10191,16 +20289,25 @@ expolsion,explosion expolsions,explosions expolsive,explosive expolsives,explosives +exponant,exponent +exponantation,exponentiation exponantial,exponential exponantially,exponentially +exponantialy,exponentially +exponants,exponents exponencial,exponential exponencially,exponentially exponental,exponential +exponentation,exponentiation exponentialy,exponentially exponentiel,exponential +exponentiell,exponential exponentiella,exponential +exponetial,exponential +exporession,expression exportas,exports exportes,exports +exportet,exported,exporter exportfs,exports exposees,exposes exposicion,exposition @@ -10208,45 +20315,110 @@ expositivo,exposition exposito,exposition exposse,exposes expotition,exposition +expport,export +exppressed,expressed exprensive,expressive -expresions,expression +expresion,expression +expresions,expression,expressions expresison,expressions +expressable,expressible expresscoin,expression expresse,expressive expressens,expresses expressie,expressive expressief,expressive expressin,expression +expressino,expression expressivos,expressions expressley,expressly -expresss,expresses +expresso,espresso +expresss,expresses,express +expresssion,expression +expresssions,expressions expresssive,expressive expressview,expressive expressy,expressly expriation,expiration +exprience,experience +exprienced,experienced +expriences,experiences expries,expires exprimental,experimental expropiated,expropriated expropiation,expropriation +exprted,exported +exptected,expected +exra,extra +exract,extract exressed,expressed +exression,expression +exsist,exists,exist +exsistence,existence +exsistent,existent +exsisting,existing +exsists,exists +exsit,exist,exit exsitance,existence exsited,existed exsitent,existent exsiting,existing +exsits,exists,exist +exspect,expect +exspected,expected +exspectedly,expectedly +exspecting,expecting +exspects,expects +exspense,expense +exspensed,expensed +exspenses,expenses +exstacy,ecstasy +exstream,extreme +extact,extract +extaction,extraction extactly,exactly +extacy,ecstasy +extarnal,external +extarnally,externally +extatic,ecstatic +extedn,extend +extedned,extended +extedner,extender +extedners,extenders +extedns,extends extemely,extremely +exten,extent +extenal,external +extendded,extended extendes,extends +extendet,extended extendos,extends +extendsions,extensions +extened,extended +exteneded,extended extenion,extension +extenions,extension,extensions +extenisble,extensible +extensability,extensibility +extensiable,extensible extensie,extensive +extensilbe,extensible extensiones,extensions extensis,extensions extensivelly,extensively extensivley,extensively extensivly,extensively +extenson,extension +extenstion,extension +extenstions,extensions +extented,extended extention,extension extentions,extensions +extepect,expect +extepecting,expecting +extepects,expects +exteral,external extered,exerted +extereme,extreme exterioara,exterior exterioare,exterior exteriour,exterior @@ -10256,18 +20428,40 @@ extermely,extremely extermism,extremism extermist,extremist extermists,extremists +extermporaneous,extemporaneous externaly,externally -extint,extinct +externel,external +externelly,externally +externels,externals +extesion,extension +extesions,extensions +extesnion,extension +extesnions,extensions +extint,extinct,extant +extist,exist +extit,exit +extited,excited,exited +extiting,exciting,exiting +extits,exits,excites +extnesion,extension extoics,exotics extortin,extortion +extrac,extract extraccion,extraction +extraced,extracted +extracing,extracting +extracter,extractor extractin,extraction +extractino,extracting +extractins,extractions extractivo,extraction extractnow,extraction extracto,extraction extradiction,extradition extradtion,extraction +extraenous,extraneous extragavant,extravagant +extranous,extraneous extraodrinarily,extraordinarily extraodrinary,extraordinary extraordianry,extraordinary @@ -10289,22 +20483,46 @@ extrapolant,extrapolate extrapolare,extrapolate extrapole,extrapolate extrapolerat,extrapolate +extrapoliate,extrapolate extrapolite,extrapolate extrapoloate,extrapolate extrapulate,extrapolate +extrat,extract +extrated,extracted extraterrestial,extraterrestrial extraterrestials,extraterrestrials +extrates,extracts +extrating,exctracting +extration,extraction +extrator,extractor +extrators,extractors +extrats,extracts extravagent,extravagant extravagina,extravagant extravegant,extravagant +extraversion,extroversion extravigant,extravagant extravogant,extravagant +extraxt,extract +extraxted,extracted +extraxting,extracting +extraxtors,extractors +extraxts,extracts +extream,extreme +extreamely,extremely +extreamily,extremely +extreamly,extremely +extreams,extremes extreem,extreme extreemly,extremely extreems,extremes +extrem,extremum,extreme +extremaly,extremely extremaste,extremes extremeley,extremely extremelly,extremely +extrememe,extreme +extrememely,extremely extrememly,extremely extremeophile,extremophile extremers,extremes @@ -10316,21 +20534,35 @@ extremistas,extremists extremiste,extremes extremistes,extremists extremistisk,extremists +extremitys,extremities extremley,extremely extremly,extremely -extrems,extremes +extrems,extremes,extrema +extrenal,external extrenally,externally +extrenaly,externally +extrime,extreme +extrimely,extremely extrimists,extremists +extrimly,extremely extroardinarily,extraordinarily extroardinary,extraordinary +extrodinary,extraordinary extropolate,extrapolate extrordinarily,extraordinarily extrordinary,extraordinary extrotion,extortion extruciating,excruciating -eyar,year -eyars,years -eyasr,years +extry,entry +exturd,extrude +exturde,extrude +exturded,extruded +exturdes,extrudes +exturding,extruding +exuberent,exuberant +eyar,year,eyas +eyars,years,eyas +eyasr,years,eyas eyeballers,eyeballs eyeballls,eyeballs eyebals,eyeballs @@ -10341,7 +20573,10 @@ eyesahdow,eyeshadow eyeshdaow,eyeshadow eygptian,egyptian eygptians,egyptians +eyt,yet eytmology,etymology +ezdrop,eavesdrop +fability,facility fabircation,fabrication faboulus,fabulous fabriacted,fabricated @@ -10354,10 +20589,14 @@ fabrikation,fabrication fabulos,fabulous facebok,facebook faceboook,facebook +facedrwaing,facedrawing +faceis,faces facepam,facepalm faceplam,facepalm faciliate,facilitate faciliated,facilitated +faciliates,facilitates +faciliating,facilitating facilisi,facilities facilitait,facilitate facilitant,facilitate @@ -10366,52 +20605,115 @@ facilitarte,facilitate facilitatile,facilitate facilites,facilities facilitiate,facilitate +facilitiates,facilitates +facilititate,facilitate facilitiy,facility facillitate,facilitate +facillities,facilities +faciltate,facilitate +facilties,facilities faciltiy,facility facinated,fascinated +facirity,facility facisnated,fascinated facisnation,fascination facist,fascist facitilies,facilities faclons,falcons +facor,favor,faker +facorite,favorite +facorites,favorites +facors,favors,fakers +facour,favour,favour +facourite,favourite +facourites,favourites +facours,favours facsinated,fascinated facsination,fascination facsism,fascism facsist,fascist facsists,fascists +factization,factorization factores,factors -factorys,factors +factorizaiton,factorization +factorys,factors,factories factuallity,factually factualy,factually facutally,factually +fadind,fading +faeture,feature +faetures,features faggotts,faggots faggotus,faggots fahernheit,fahrenheit fahrenheight,fahrenheit fahrenhiet,fahrenheit +faied,failed,fade +faield,failed +faild,failed +failded,failed +faile,failed +failer,failure +failes,fails +failicies,facilities +failicy,facility +failied,failed +failiure,failure +failiures,failures +failiver,failover +faill,fail +failled,failed +faillure,failure +failng,failing +failre,failure +failrue,failure +failsave,failsafe +failsaves,failsafes +failt,fail,failed +failture,failure +failue,failure +failuer,failure +failues,failures failurs,failures faincee,fiancee +faireness,fairness +fairoh,pharaoh +faiway,fairway +faiways,fairways falcones,falcons falesly,falsely +falg,flag +falgs,flags falgship,flagship +falied,failed falired,flaired +faliure,failure faliures,failures +fallabck,fallback fallatious,fallacious +fallbck,fallback +fallhrough,fallthrough fallicious,fallacious +fallthruogh,fallthrough +falltrough,fallthrough falmethrower,flamethrower falseley,falsely +falsh,flash,false falshbacks,flashbacks falshed,flashed falshes,flashes falshing,flashing falsley,falsely +falsly,falsely +falt,fault +falure,failure falvored,flavored falvors,flavors falvours,flavours familair,familiar familairity,familiarity familairize,familiarize +familar,familiar familes,families familiair,familiar familiare,familiarize @@ -10422,7 +20724,12 @@ familiarty,familiarity familiary,familiarity familiarze,familiarize familierize,familiarize +familiies,families +familiy,family familliar,familiar +familly,family +famlilies,families +famlily,family famoulsy,famously famoust,famous famousy,famously @@ -10436,6 +20743,7 @@ fanatsies,fantasies fanatsize,fantasize fanatsizing,fantasizing fanatsy,fantasy +fancyness,fanciness fandation,foundation fanfaction,fanfiction fanfcition,fanfiction @@ -10465,9 +20773,15 @@ fantistically,fantastically faoming,foaming faptastically,fantastically farcking,fracking +farction,fraction,faction farehnheit,fahrenheit +farenheight,fahrenheit farenheit,fahrenheit +farest,fairest,farthest farhenheit,fahrenheit +faries,fairies +farmework,framework +fasade,facade fascianted,fascinated fascinacion,fascination fascinatie,fascinated @@ -10479,6 +20793,9 @@ fascistes,fascists fascistisk,fascists fascits,fascist fascization,fascination +fase,faze,phase +fased,fazed,phased +fases,fazes,phases fashionalbe,fashionable fashionalble,fashionable fashiond,fashioned @@ -10487,13 +20804,31 @@ fashoined,fashioned fasicsm,fascism fasicst,fascist fasicsts,fascists +fasing,fazing,phasing +fasion,fashion faslely,falsely +fassade,facade +fassinate,fascinate +fasterner,fastener +fasterners,fasteners +fastr,faster fatalaties,fatalities fatalitites,fatalities fatc,fact +fater,faster +fatig,fatigue fatigure,fatigue fatiuge,fatigue +fatser,faster +fature,feature faught,fought +fauilure,failure +fauilures,failures +faund,found,fund +fauture,feature +fautured,featured +fautures,features +fauturing,featuring favoritisme,favorites favorits,favorites favorties,favorites @@ -10506,23 +20841,62 @@ favouritsm,favourites favourtie,favourite favourties,favourites favoutrable,favourable +favuourites,favourites +faymus,famous +fcound,found +feasabile,feasible +feasability,feasibility feasable,feasible feasbile,feasible +featch,fetch,each +featchd,fetched +featched,fetched +featcher,feather,feature,fetcher +featches,fetches,features +featching,fetching +featchs,fetches +featchss,fetches +featchure,feature +featchured,featured +featchures,features +featchuring,featuring +featre,feature +featue,feature +featued,featured +featues,features +featur,feature +featurs,features +feautre,feature +feauture,feature +feautures,features +febewary,february febraury,february februray,february febuary,february feburary,february fecthed,fetched fecthes,fetches +fecthing,fetching +fedality,fidelity federacion,federation federativo,federation fedility,fidelity fedorahs,fedoras fedorans,fedoras fedreally,federally +feeback,feedback +feeded,fed +feek,feel +feeks,feels +feets,feet,feats +feetur,feature +feeture,feature +feild,field feilding,fielding feisable,feasible feitshes,fetishes +feld,field +felisatus,felicitous fellowhsip,fellowship fellowshop,fellowship feltcher,fletcher @@ -10541,7 +20915,10 @@ feminitity,femininity feminsim,feminism feminsits,feminists femminist,feminist +fempto,femto feodras,fedoras +feonsay,fiancée +fequency,frequency fermantation,fermentation fermentacion,fermentation fermentaion,fermentation @@ -10553,6 +20930,7 @@ fermintation,fermentation feromone,pheromone fertalizer,fertilizer fertelizer,fertilizer +fertil,fertile fertilizar,fertilizer fertilizier,fertilizer fertily,fertility @@ -10566,22 +20944,44 @@ festivalens,festivals festivales,festivals festivas,festivals festivle,festive +fetaure,feature +fetaures,features +fetchs,fetches fethced,fetched fethces,fetches fetishers,fetishes fetishiste,fetishes fetishs,fetishes +fetures,features +fewd,few,feud +fewg,few,fugue +fewsha,fuchsia +fezent,pheasant +fhurter,further +fials,fails fianite,finite fianlly,finally +ficks,flicks,fix ficticious,fictitious fictionaries,dictionaries fictious,fictitious +fidality,fidelity +fiddley,fiddly fideling,fielding fideltiy,fidelity fidn,find +fied,field fiedling,fielding fiedlity,fidelity -fiels,fields +fieid,field +fiel,feel,field,file,phial +fieldlst,fieldlist +fieled,field +fielesystem,filesystem +fielesystems,filesystems +fielname,filename +fielneame,filename +fiels,fields,feels,files,phials fiercly,fiercely fighitng,fighting fightings,fighting @@ -10594,29 +20994,98 @@ figurativeley,figuratively figurativelly,figuratively figurativley,figuratively figurativly,figuratively +figurestyle,figurestyles figuretively,figuratively figuritively,figuratively +fike,file +filal,final filcker,flicker fileding,fielding +fileds,fields +fileld,field +filelds,fields +filenae,filename +filenname,filename +fileshystem,filesystem +fileshystems,filesystems +filesname,filename,filenames +filesnames,filenames +filess,files +filesstem,filesystem filessytem,filesystem -filesytems,filesystem +filessytems,filesystems +fileststem,filesystem +filesysems,filesystems +filesysthem,filesystem +filesysthems,filesystems +filesystmes,filesystems +filesystyem,filesystem +filesystyems,filesystems +filesytem,filesystem +filesytems,filesystem,filesystems +fileter,filter filetimes,lifetimes +fileystem,filesystem +fileystems,filesystems filiament,filament +fillay,fillet +filld,filled,filed,fill +fille,file,fill,filled +fillement,filament +filles,files,fills,filled +fillowing,following +fillung,filling filmamkers,filmmakers filmmakare,filmmakers filmmakes,filmmakers +filnal,final +filname,filename +filp,flip filpped,flipped +filpping,flipping +filps,flips +fils,fills,files,file +filse,files +filsystem,filesystem +filsystems,filesystems filterd,filtered +filterig,filtering +filterring,filtering +filtersing,filtering +filterss,filters +fime,fixme,time fimilies,families +fimrware,firmware +fimware,firmware finacee,fiancee finacial,financial +finailse,finalise +finailze,finalize +finalle,finale,finally finallizes,finalizes -finaly,finally +finaly,finally,finale +finanace,finance +finanaced,financed +finanaces,finances +finanacially,financially +finanacier,financier financialy,financially finanically,financially +finanize,finalize +finanlize,finalize finantially,financially +fincally,finally +finctional,functional,fictional +finctionalities,functionalities +finctionality,functionality +finde,find +findn,find +finelly,finally fineses,finesse fineshes,finesse +finess,finesse +finge,finger,fringe +fingeprint,fingerprint fingernal,fingernails fingernals,fingernails fingerpies,fingertips @@ -10629,12 +21098,34 @@ fingertaps,fingertips fingertits,fingertips fingertops,fingertips fingertrips,fingertips +finialization,finalization +finializing,finalizing +finilizes,finalizes fininsh,finnish +finisch,finish,finnish +finisched,finished +finishe,finished,finish +finishied,finished finishs,finishes finisse,finishes +finitel,finite +finness,finesse finnisch,finnish +finnished,finished finnsih,finnish +finsh,finish,finch +finshed,finished +finshes,finishes,finches +finshing,finishing +finsih,finish +finsihed,finished finsihes,finishes +finsihing,finishing +finsished,finished +finxed,fixed +finxing,fixing +fiorget,forget +firdt,first,third fireballls,fireballs firebals,fireballs firefigher,firefighter @@ -10646,32 +21137,86 @@ firendlies,friendlies firendly,friendly firends,friends firendzoned,friendzoned +firest,fires,first +firey,fiery firggin,friggin firghtened,frightened firghtening,frightening +firmare,firmware +firmaware,firmware +firmeare,firmware +firmeware,firmware +firmnware,firmware +firmwart,firmware firmwear,firmware +firmwqre,firmware +firmwre,firmware +firmwware,firmware firsbee,frisbee firslty,firstly -firts,flirts +firsr,first +firsth,first +firt,first,flirt +firts,flirts,first firtsly,firstly +firware,firmware firwmare,firmware +fisical,physical,fiscal fisionable,fissionable +fisisist,physicist +fisist,physicist +fisrt,first +fiter,filter,fighter,fitter,fiver +fitering,filtering +fiters,filters,fighters,fitters,fivers +fitler,filter fitlers,filters +fivety,fifty +fixe,fixed,fixes,fix,fixme,fixer +fixeme,fixme +fixwd,fixed +fizeek,physique flacons,falcons +flacor,flavor +flacored,flavored +flacoring,flavoring +flacorings,flavorings +flacors,flavors +flacour,flavour +flacoured,flavoured +flacouring,flavouring +flacourings,flavourings +flacours,flavours +flage,flags,flag +flaged,flagged +flages,flags +flagg,flag flaghsip,flagship +flahs,flash,flags flahsed,flashed flahses,flashes +flahsing,flashing +flakyness,flakiness flamable,flammable flamethorwer,flamethrower flametrhower,flamethrower flanethrower,flamethrower +flaot,float +flaoting,floating flaried,flaired flasely,falsely flasghip,flagship +flashflame,flashframe flashig,flashing flashligt,flashlight flashligth,flashlight +flasing,flashing flaskbacks,flashbacks +flass,class,glass,flask,flash +flate,flat +flatened,flattened +flattend,flattened +flattenning,flattening flatterd,flattered flatterende,flattered flatteur,flatter @@ -10688,32 +21233,46 @@ flawlessely,flawlessly flawlessley,flawlessly flawlessy,flawlessly flciker,flicker +fle,file flechter,fletcher flecther,fletcher -fleed,fled +fleed,fled,freed +flem,phlegm flemmish,flemish flethcer,fletcher +flewant,fluent +flexability,flexibility +flexable,flexible flexbile,flexible flexibel,flexible +flexibele,flexible flexibiliy,flexibility flexibillity,flexibility flexibiltiy,flexibility flexibilty,flexibility flexibily,flexibility +flext,flex +flie,file flimmakers,filmmakers flippade,flipped flitered,filtered fliters,filters +floading,floating,flooding flordia,florida florecen,florence florene,florence +floresent,fluorescent,florescent +floride,fluoride floridia,florida floruide,fluoride floruish,flourish -flourescent,fluorescent +floting,floating +flourescent,fluorescent,florescent +flouride,fluoride flourine,fluorine flourishment,flourishing floursih,flourish +flter,filter fluctaute,fluctuate fluctiations,fluctuations fluctuatie,fluctuate @@ -10722,33 +21281,278 @@ fluctuatin,fluctuations fluctuative,fluctuate flucutate,fluctuate flucutations,fluctuations +flud,flood fluorish,flourish +fluoroscent,fluorescent +fluroescent,fluorescent fluroide,fluoride +flushs,flushes +flusing,flushing flutterhsy,fluttershy fluttersky,fluttershy flutterspy,fluttershy fluttersy,fluttershy flutteryshy,fluttershy fluxtuations,fluctuations +flyes,flies,flyers fnaatic,fanatic +fo,of,for +focu,focus +focued,focused +focument,document +focuse,focus +focusf,focus +focuss,focus +focusses,focuses +fof,for +foget,forget +fogot,forgot +fogotten,forgotten +fointers,pointers +folde,folder,fold +foler,folder +folers,folders +folfer,folder +folfers,folders +folled,followed +foller,follower +follers,followers +follew,follow +follewed,followed +follewer,follower +follewers,followers +follewin,following +follewind,following +follewing,following +follewinwg,following +follewiong,following +follewiwng,following +follewong,following +follews,follows +follfow,follow +follfowed,followed +follfower,follower +follfowers,followers +follfowin,following +follfowind,following +follfowing,following +follfowinwg,following +follfowiong,following +follfowiwng,following +follfowong,following +follfows,follows +follin,following +follind,following +folling,following,falling,rolling +follinwg,following +folliong,following +folliw,follow +folliwed,followed +folliwer,follower +folliwers,followers +folliwin,following +folliwind,following +folliwing,following +folliwinwg,following +folliwiong,following +folliwiwng,following +folliwng,following +folliwong,following +folliws,follows +folllow,follow +folllowed,followed +folllower,follower +folllowers,followers +folllowin,following +folllowind,following +folllowing,following +folllowinwg,following +folllowiong,following +folllowiwng,following +folllowong,following +folllows,follows,followings +follod,followed +folloeing,following +folloing,following +folloiwng,following +follong,following +followd,followed,follows,follow +followig,following +followign,following +followin,following +followind,following +followng,following +folls,follows +follw,follow +follwed,followed +follwer,follower +follwers,followers +follwin,following +follwind,following +follwing,following +follwinwg,following +follwiong,following +follwiwng,following +follwo,follow +follwoe,follow +follwoed,followed +follwoeed,followed +follwoeer,follower +follwoeers,followers +follwoein,following +follwoeind,following +follwoeing,following +follwoeinwg,following +follwoeiong,following +follwoeiwng,following +follwoeong,following +follwoer,follower +follwoers,followers +follwoes,follows +follwoin,following +follwoind,following follwoing,following +follwoinwg,following +follwoiong,following +follwoiwng,following +follwong,following +follwoong,following +follwos,follows +follwow,follow +follwowed,followed +follwower,follower +follwowers,followers +follwowin,following +follwowind,following +follwowing,following +follwowinwg,following +follwowiong,following +follwowiwng,following +follwowong,following +follwows,follows +follws,follows +follww,follow +follwwed,followed +follwwer,follower +follwwers,followers +follwwin,following +follwwind,following +follwwing,following +follwwinwg,following +follwwiong,following +follwwiwng,following +follwwong,following +follwws,follows +foloow,follow +foloowed,followed +foloower,follower +foloowers,followers +foloowin,following +foloowind,following +foloowing,following +foloowinwg,following +foloowiong,following +foloowiwng,following +foloowong,following +foloows,follows +folow,follow +folowed,followed +folower,follower +folowers,followers +folowin,following +folowind,following folowing,following +folowinwg,following +folowiong,following +folowiwng,following +folowong,following +folows,follows +foloww,follow +folowwed,followed +folowwer,follower +folowwers,followers +folowwin,following +folowwind,following +folowwing,following +folowwinwg,following +folowwiong,following +folowwiwng,following +folowwong,following +folowws,follows +folse,false +folwo,follow +folwoed,followed +folwoer,follower +folwoers,followers +folwoin,following +folwoind,following +folwoing,following +folwoinwg,following +folwoiong,following +folwoiwng,following +folwoong,following +folwos,follows +folx,folks fomaing,foaming +fomat,format +fomated,formatted +fomater,formatter +fomates,formats +fomating,formatting +fomats,formats +fomatted,formatted +fomatter,formatter fomed,formed -fomr,from +fomr,from,form +fomrat,format +fomrated,formatted +fomrater,formatter +fomrating,formatting +fomrats,formats +fomratted,formatted +fomratter,formatter +fomratting,formatting +fonction,function +fonctional,functional +fonctionalities,functionalities +fonctioning,functioning +fonctionnalies,functionalities +fonctionnalities,functionalities +fonctionnality,functionality +fonctionnaly,functionally,functionality +fonctions,functions fondamentalist,fundamentalist fondamentalists,fundamentalists fonetic,phonetic +fontain,fountain,contain +fontains,fountains,contains fontier,frontier +fontonfig,fontconfig fontrier,frontier +fonud,found +foontnotes,footnotes foootball,football +foorter,footer +footnoes,footnotes +foppy,floppy +foppys,floppies +foramatting,formatting +foramt,format forasken,forsaken +forat,format +forbad,forbade +forbbiden,forbidden forbiden,forbidden +forbit,forbid +forbiten,forbidden +forbitten,forbidden +forcably,forcibly forcefullly,forcefully forcefuly,forcefully forcibley,forcibly forciblly,forcibly forcifully,forcefully +forcot,forgot foreamrs,forearms forearmes,forearms forecfully,forcefully @@ -10765,6 +21569,7 @@ foreing,foreign foreinger,foreigner foreingers,foreigners foreksin,foreskin +forementionned,aforementioned forenics,forensic forenisc,forensic forensisch,forensic @@ -10773,10 +21578,11 @@ foreseeble,foreseeable foreshadowning,foreshadowing foresnic,forensic foresseable,foreseeable -foreward,foreword +foreward,foreword,forward forfiet,forfeit forgeiner,foreigner forgeiners,foreigners +forgeround,foreground forgettting,forgetting forgiener,foreigner forgieners,foreigners @@ -10785,7 +21591,9 @@ forgivenness,forgiveness forgivens,forgiveness forgivenss,forgiveness forgiviness,forgiveness +forgoten,forgotten forgotting,forgetting +forground,foreground forhead,forehead foricbly,forcibly foriegn,foreign @@ -10793,20 +21601,34 @@ foriegner,foreigner foriegners,foreigners forigener,foreigner forigven,forgiven +forld,fold +forlder,folder +forlders,folders formadible,formidable formalhaut,fomalhaut formallity,formally formallize,formalize formallized,formalized -formaly,formally +formaly,formally,formerly +formate,format +formated,formatted +formater,formatter +formates,formats formatiing,formatting formatin,formation +formating,formatting formatings,formations formativos,formations +formatteded,formatted +formattind,formatting +formattted,formatted formattting,formatting formelly,formerly +formely,formerly +formend,formed formerlly,formerly formery,formerly +formes,forms,formed formidabble,formidable formidabel,formidable formidabelt,formidable @@ -10815,7 +21637,10 @@ formidabile,formidable formidible,formidable forminable,formidable formitable,formidable +formmatted,formatted formost,foremost +formt,format +formua,formula formual,formula formuals,formulas formualte,formulate @@ -10827,44 +21652,83 @@ formuls,formulas fornesic,forensic forntline,frontline forntpage,frontpage +forr,for forresst,forrest forrset,forrest forsakn,forsaken forsane,forsaken forsaw,foresaw +forse,force forseeable,foreseeable forsekan,forsaken forsekin,foreskin forsenic,forensic forskaen,forsaken +forst,first,forced forsting,frosting +fortan,fortran +fortat,format +forteen,fourteen fortelling,foretelling +forthcominng,forthcoming +forthcomming,forthcoming fortitudine,fortitude fortitue,fortitude fortuante,fortunate fortuantely,fortunately fortunae,fortune +fortunaly,fortunately fortunantly,fortunately +fortunat,fortunate fortunatelly,fortunately fortunatley,fortunately fortunatly,fortunately fortunetely,fortunately fortunetly,fortunately fortunte,fortune +forula,formula +forulas,formulas forumla,formula forumlas,formulas forumlate,formulate +forumula,formula +forumulas,formulas +forunate,fortunate +forunately,fortunately forunner,forerunner +forutunate,fortunate +forutunately,fortunately +forver,forever +forwad,forward +forwaded,forwarded +forwading,forwarding +forwads,forwards +forwardig,forwarding +forwared,forwarded,forward +forwaring,forwarding +forwwarded,forwarded fossiles,fossils fossilis,fossils +fot,for,fit,dot,rot,cot,got,tot,fog +foto,photo +fotograf,photograph +fotografic,photographic +fotografical,photographical +fotografy,photography +fotograph,photograph +fotography,photography foucs,focus foudn,found +foudning,founding fougth,fought +foult,fault +foults,faults foundaiton,foundations foundaries,foundries foundary,foundry foundatin,foundations foundatoin,foundations +foundland,newfoundland fountan,fountain fountian,fountain fourteeen,fourteen @@ -10873,7 +21737,13 @@ fourties,forties fourty,forty fouth,fourth foward,forward +fowarded,forwarded +fowarding,forwarding +fowards,forwards fowrards,forwards +fpr,for,far,fps +fprmat,format +fracional,fractional frackign,fracking fractalers,fractals fractales,fractals @@ -10884,11 +21754,32 @@ fractalus,fractals fracter,fracture fracturare,fracture fragement,fragment +fragementation,fragmentation +fragements,fragments +fragmant,fragment +fragmantation,fragmentation fragmanted,fragment +fragmants,fragments +fragmenet,fragment +fragmenetd,fragmented +fragmeneted,fragmented +fragmeneting,fragmenting +fragmenets,fragments fragmenot,fragment fragmet,fragment +fragmnet,fragment +frambuffer,framebuffer +framebufer,framebuffer +framei,frame framethrower,flamethrower +frametyp,frametype +frameworkk,framework framgent,fragment +framlayout,framelayout +framming,framing +framwework,framework +framwork,framework +framworks,frameworks francaises,franchises franches,franchise franchices,franchises @@ -10900,6 +21791,7 @@ franchizes,franchises franchsies,franchises franciso,francisco francsico,francisco +frane,frame frankensite,frankenstein frankenstain,frankenstein frankensteen,frankenstein @@ -10910,6 +21802,7 @@ frankenstined,frankenstein frankenstiner,frankenstein frankenstines,frankenstein frankiln,franklin +frankin,franklin frankinstein,frankenstein franlkin,franklin franscico,francisco @@ -10917,6 +21810,7 @@ fransiscan,franciscan fransiscans,franciscans franticaly,frantically franticlly,frantically +franzise,franchise fraternaty,fraternity fraternety,fraternity fraterntiy,fraternity @@ -10928,12 +21822,25 @@ fraudolent,fraudulent fraudulant,fraudulent freckels,freckles frecklers,freckles +frecuencies,frequencies +frecuency,frequency +frecuent,frequent +frecuented,frequented +frecuently,frequently +frecuents,frequents +freecallrelpy,freecallreply freedomers,freedoms freedomes,freedoms freedomest,freedoms +freedon,freedom +freedons,freedoms freedos,freedoms +freee,free +freeed,freed freestlye,freestyle freesytle,freestyle +freez,frees,freeze +freezs,freezes freind,friend freindlies,friendlies freindly,friendly @@ -10943,15 +21850,30 @@ freindships,friendships freindzoned,friendzoned frementation,fermentation fremented,fermented +freqencies,frequencies +freqency,frequency freqeuncy,frequency +frequancies,frequencies +frequancy,frequency +frequant,frequent +frequantly,frequently frequence,frequencies +frequences,frequencies frequencey,frequency +frequenct,frequency,frequent frequenices,frequencies +frequenies,frequencies frequensies,frequencies frequenties,frequencies frequentily,frequently -frequeny,frequency +frequeny,frequency,frequently,frequent frequenzies,frequencies +frequncies,frequencies +frequncy,frequency +freze,freeze +frezes,freezes +frgament,fragment +fricton,friction friednship,friendships friednzone,friendzoned friendboned,friendzoned @@ -10980,25 +21902,42 @@ frigthening,frightening frimware,firmware frinedzoned,friendzoned fringeworthy,cringeworthy +frist,first fristly,firstly +frmat,format +frmo,from +froce,force frogiven,forgiven frointer,frontier +frok,from +fromal,formal +fromat,format fromation,formation fromatting,formatting frome,from fromed,formed fromerly,formerly fromidable,formidable +froms,forms +fron,from +fronend,frontend +fronends,frontends froniter,frontier fronkenstein,frankenstein frontapge,frontpage fronteir,frontier +frontent,frontend +frontents,frontends frontilne,frontline frontlinie,frontline frontlinies,frontline frontlinjen,frontline +frop,drop +fropm,from +frops,drops frosaken,forsaken frostig,frosting +frozee,frozen frsibee,frisbee fruadulent,fraudulent fruitin,fruition @@ -11020,45 +21959,97 @@ frustrato,frustration frustrats,frustrates frustrsted,frustrates frutcose,fructose +fschk,fsck +ftrunacate,ftruncate +fualt,fault +fualts,faults fucntion,function fucntional,functional fucntionality,functionality fucntionally,functionally fucntioning,functioning fucntions,functions +fuction,function +fuctionoid,functionoid +fuctions,functions fufill,fulfill fufilled,fulfilled +fugure,figure +fugured,figured +fugures,figures +fule,file fulfiled,fulfilled fulfillling,fulfilling fulfulling,fulfilling fulfullment,fulfillment fullets,fullest +fullfil,fulfil,fulfil +fullfiled,fulfilled fullfiling,fulfilling -fullfill,fulfill +fullfill,fulfill,fulfill fullfilled,fulfilled +fullfilling,fulfilling +fullfills,fulfills fullfilment,fulfilment +fullfils,fulfils,fulfils +fullill,fulfill,fulfill +fullly,fully fullscrean,fullscreen fullscreeen,fullscreen fullscren,fullscreen fullset,fullest +fulsh,flush fulttershy,fluttershy +funcation,function +funchtion,function +funchtional,functional +funchtioned,functioned +funchtioning,functioning +funchtionn,function +funchtionnal,functional +funchtionned,functioned +funchtionning,functioning +funchtionns,functions +funchtions,functions +funcion,function +funcions,functions funciton,function funcitonal,functional funcitonality,functionality funcitonally,functionally +funcitoned,functioned funcitoning,functioning funcitons,functions -functionable,functional +functin,function +functinality,functionality +functino,function +functins,functions +functionability,functionality +functionable,functional,functioning functionailty,functionality functionaliy,functionally functionallity,functionality +functionaltiy,functionality functionalty,functionality functionaly,functionally functiong,functioning functionlity,functionality functionnal,functional +functionnalities,functionalities +functionnality,functionality +functionnaly,functionally functionning,functioning +functionon,function +functionss,functions +functios,functions +functiosn,functions +functon,function +functonal,functional +functonality,functionality +functoning,functioning +functons,functions functtion,function +funczion,function fundamendalist,fundamentalist fundamendalists,fundamentalists fundamentais,fundamentals @@ -11088,6 +22079,7 @@ fundamnetal,fundamentals fundamnetalist,fundamentalist fundamnetalists,fundamentalists fundamnetally,fundamentally +fundation,foundation fundemantal,fundamental fundemantalist,fundamentalist fundemantalists,fundamentalists @@ -11103,28 +22095,76 @@ fundimentals,fundamentals fundirse,fundies fundumentalist,fundamentalist fundumentalists,fundamentalists +funguses,fungi funides,fundies +funktion,function funniliy,funnily funnilly,funnily +funnnily,funnily funtion,function +funtional,functional +funtionalities,functionalities +funtionality,functionality +funtionallity,functionality +funtionally,functionally +funtionalty,functionality +funtioning,functioning +funtions,functions furance,furnace furctose,fructose +furether,further +furethermore,furthermore +furethest,furthest +furfill,fulfill +furher,further +furhermore,furthermore +furhest,furthest +furhter,further furhtermore,furthermore +furhtest,furthest furiosuly,furiously furition,fruition furiuosly,furiously +furmalae,formulae +furmula,formula +furmulae,formulae furncae,furnace +furneture,furniture +furser,further +fursermore,furthermore +fursest,first,furthest +furst,first +fursther,further +fursthermore,furthermore +fursthest,furthest furstrated,frustrated furstrates,frustrates furstration,frustration furstrations,frustrations +furter,further +furthemore,furthermore +furthermor,furthermore furthremore,furthermore +furthur,further furthurmore,furthermore +furture,future +furure,future +furute,fruit,future furuther,further furutistic,futuristic +furutre,future +furzzer,fuzzer +fuschia,fuchsia +fushed,flushed +fushing,flushing +futer,further futher,further +futherize,further futhermore,furthermore -futhroc,futhark +futhroc,futhark,futhorc +futrue,future +futrure,future +futture,future futurers,futures futurestic,futuristic futureus,futures @@ -11134,6 +22174,14 @@ futuristc,futuristic futuristisch,futuristic futurustic,futuristic fwankenstein,frankenstein +fwe,few +fwirte,fwrite +fxed,fixed +fysical,physical +fysisist,physicist +fysisit,physicist +gabage,garbage +gadged,gadget,gauged gadgest,gadgets gagdets,gadgets gagnsters,gangsters @@ -11141,6 +22189,8 @@ galatic,galactic galations,galatians galcier,glacier galdiator,gladiator +gallaries,galleries +gallary,gallery gallaxies,galaxies galsgow,glasgow galvinized,galvanized @@ -11151,6 +22201,7 @@ gamerga,gamertag gamergat,gamertag gamifications,ramifications gammeode,gamemode +ganbia,gambia ganerate,generate ganes,games gangsterest,gangsters @@ -11161,12 +22212,20 @@ garabge,garbage garantee,guarantee garanteed,guaranteed garantees,guarantees +garantied,guaranteed +garanty,guarantee +garbadge,garbage +garbagge,garbage +garbarge,garbage +gard,guard gardai,gardaí gardient,gradient +garentee,guarantee garfeild,garfield garfied,garfield garfiled,garfield garflied,garfield +gargage,garbage,garage garnison,garrison garnola,granola garrions,garrison @@ -11175,9 +22234,18 @@ garrsion,garrison garuantee,guarantee garuanteed,guaranteed garuantees,guarantees +garuantied,guaranteed +gatable,gateable +gateing,gating gatherig,gatherings gatherins,gatherings +gatway,gateway +gauage,gauge gauarana,guaraná +gauarantee,guarantee +gauaranteed,guaranteed +gauarentee,guarantee +gauarenteed,guaranteed gauntanamo,guantanamo gauntelt,gauntlet gauntelts,gauntlets @@ -11187,19 +22255,45 @@ gauntles,gauntlets gauntlettes,gauntlets gaurantee,guarantee gauranteed,guaranteed +gauranteeing,guaranteeing gaurantees,guarantees -gaurd,guard +gaurd,guard,gourd gaurdian,guardian gaurding,guarding gaurentee,guarantee gaurenteed,guaranteed gaurentees,guarantees +gaus,gauss,gauze +gausian,gaussian gautnlet,gauntlet +geenrate,generate +geenrated,generated +geenrates,generates +geenration,generation +geenrational,generational +geeoteen,guillotine +geeral,general +gemetrical,geometrical +gemetry,geometry gemoetry,geometry +genarate,generate +genarated,generated +genarating,generating +genaration,generation genatilia,genitalia +genearal,general +genearally,generally +genearted,generated +geneate,generate +geneated,generated +geneates,generates +geneating,generating +geneation,generation +geneic,generic,genetic geneological,genealogical geneologies,genealogies geneology,genealogy +generaates,generates generacional,generational generalbs,generals generalice,generalize @@ -11212,32 +22306,66 @@ generalizate,generalize generalizating,generalization generalizaton,generalization generalizng,generalizing +generall,generally,general generalnie,generalize generaly,generally +generalyl,generally +generalyse,generalise generas,generals generase,generates generaste,generates -generaters,generates +generat,generate,general +generater,generator +generaters,generates,generators generatie,generate generaties,generate +generatig,generating generatin,generations generationals,generations generationens,generations generationers,generations generationnal,generational generatios,generators +generatng,generating +generaton,generation,generator generatons,generators generatore,generate generatos,generators generats,generates generatting,generating +genereate,generate +genereated,generated +genereates,generates +genereating,generating +genered,generated +genereic,generic generelization,generalization generelize,generalize generelizing,generalizing +generell,general +generelly,generally +genererate,generate +genererated,generated +genererater,generator +genererating,generating +genereration,generation +genereted,generated +generilise,generalise +generilised,generalised +generilises,generalises +generilize,generalize +generilized,generalized +generilizes,generalizes +generiously,generously generocity,generosity generoisty,generosity generostiy,generosity genersl,generals +generted,generated +generting,generating +genertion,generation +genertor,generator +genertors,generators geneticaly,genetically geneticlly,genetically genialia,genitalia @@ -11250,21 +22378,55 @@ genitaliban,genitalia genitalis,genitals geniunely,genuinely geniuss,geniuses +genral,general +genralisation,generalisation +genralisations,generalisations +genralise,generalise +genralised,generalised +genralises,generalises +genralization,generalization +genralizations,generalizations +genralize,generalize +genralized,generalized +genralizes,generalizes +genrally,generally +genrals,generals +genrate,generate +genrated,generated genrates,generates +genratet,generated +genrating,generating +genration,generation +genrations,generations +genrator,generator +genrators,generators +genreate,generate +genreated,generated +genreates,generates +genreating,generating +genric,generic +genrics,generics gentailia,genitalia +gental,gentle gentelmen,gentlemen gentialia,genitalia gentials,genitals gentlemanne,gentlemen gentlemn,gentlemen genuienly,genuinely +genuin,genuine genuinelly,genuinely genuinley,genuinely genuises,geniuses +geocentic,geocentric +geoemtries,geometries +geoemtry,geometry +geogcountry,geocountry geograhpical,geographical geographacilly,geographically geographia,geographical geographicaly,geographically +geographich,geographic geographicial,geographical geographicly,geographical geographisch,geographic @@ -11275,37 +22437,99 @@ geogrpahic,geographic geogrpahical,geographical geogrpahically,geographically geogrpahy,geography +geoio,geoip geomerty,geometry +geomery,geometry +geometites,geometries +geometrc,geometric,geometry +geometrician,geometer geometricians,geometers +geometrie,geometry +geometrys,geometries geomety,geometry +geometyr,geometry +geomitrically,geometrically +geomoetric,geometric +geomoetrically,geometrically +geomoetry,geometry geomtery,geometry +geomtry,geometry +geomtrys,geometries geopraphically,geographically +georeferncing,georeferencing georiga,georgia +geraff,giraffe +geraphics,graphics gerat,great +gereating,generating +gererate,generate +gererated,generated +gerilla,guerilla germaniac,germanic germanisch,germanic germanos,germans germanus,germans gernade,grenade gernades,grenades +gernal,general,journal +gerneral,general +gernerally,generally +gerneraly,generally +gernerate,generate +gernerated,generated +gernerates,generates +gernerating,generating +gerneration,generation +gernerator,generator +gernerators,generators +gerneric,generic +gernerics,generics gerogia,georgia +gess,guess +getfastproperyvalue,getfastpropertyvalue +getimezone,gettimezone +geting,getting +getlael,getlabel +getoe,ghetto +getoject,getobject +gettetx,gettext +gettitem,getitem +gettitems,getitems +gettter,getter +gettters,getters +getttext,gettext +getttime,gettime +getttimeofday,gettimeofday +gettting,getting geurrilla,guerrilla +ggogle,goggle,google +ggogled,googled +ggogles,goggles,googles ghandi,gandhi +ghostscritp,ghostscript +ghraphic,graphic giagbyte,gigabyte gigabtye,gigabyte gigabye,gigabyte gigantisch,gigantic gigaybte,gigabyte gigbayte,gigabyte +gigibit,gigabit gignatic,gigantic +gilotine,guillotine giltched,glitched giltches,glitches giltchy,glitchy +gilty,guilty gimmickers,gimmicks gimmickey,gimmicky gimmickly,gimmicky gimmics,gimmicks gimmicy,gimmicky +ginee,guinea +gingam,gingham +gioen,given +gir,git girafffe,giraffe girefing,griefing girlfirend,girlfriend @@ -11319,6 +22543,17 @@ girlfrinds,girlfriends girlfrined,girlfriends girlling,grilling girzzly,grizzly +giser,geyser +gisers,geysers +gitar,guitar +gitars,guitars +gitatributes,gitattributes +gived,given,gave +giveing,giving +givem,given +givveing,giving +givven,given +givving,giving gladiatr,gladiator glagsow,glasgow glaicer,glacier @@ -11339,26 +22574,43 @@ glitchty,glitchy glithced,glitched glithces,glitches glithcy,glitchy +gloab,globe +gloabal,global gloabl,global gloablly,globally +globablly,globally globaly,globally +globbal,global +globel,global glodberg,goldberg glodfish,goldfish gloiath,goliath +glorfied,glorified glorifierad,glorified glorifindel,glorified glorios,glorious gloriuos,glorious +glpyh,glyph +glpyhs,glyphs gltiched,glitched gltiches,glitches gltichy,glitchy +glyh,glyph +glyhs,glyphs +glyped,glyphed +glyphes,glyphs +glyping,glyphing +glyserin,glycerin gmaertag,gamertag gnaking,ganking gnawwed,gnawed +gnerate,generate +gnorung,ignoring goalkeaper,goalkeeper goalkeepr,goalkeeper goalkeeprs,goalkeeper goalkepeer,goalkeeper +gobal,global goblings,goblins godafther,godfather goddammn,goddamn @@ -11380,12 +22632,20 @@ goegraphic,geographic goegraphical,geographical goegraphically,geographically goegraphy,geography +goemetries,geometries goergia,georgia -gogin,going +goess,goes +gogether,together +gogin,going,gauguin goign,going goilath,goliath +goin,going +goind,going golaith,goliath golakeeper,goalkeeper +golbal,global +golbally,globally +golbaly,globally golbins,goblins goldamn,goldman goldbeg,goldberg @@ -11399,21 +22659,26 @@ gongratulations,congratulations gonig,going goodlcuk,goodluck goodluk,goodluck +gool,ghoul goosebumbps,goosebumps goosebumbs,goosebumps goosebums,goosebumps goosegumps,goosebumps goosepumps,goosebumps +gord,gourd goregous,gorgeous goreshadowing,foreshadowing gorgoeus,gorgeous gorillia,gorilla gorillla,gorilla +gormay,gourmet +gorry,gory gorumet,gourmet gorvement,government gosepls,gospels gospells,gospels gosples,gospels +gost,ghost gothenberg,gothenburg gottleib,gottlieb gourmelt,gourmet @@ -11422,6 +22687,7 @@ gouvener,governor govement,government govemrent,government govenment,government +govenor,governor govenrment,government govenrments,governments goverance,governance @@ -11434,6 +22700,7 @@ govermet,government govermetn,government govermnent,governments govermnet,government +govermnment,government governemnt,government governemntal,governmental governemnts,governments @@ -11455,6 +22722,8 @@ govornment,government govrement,government gpysies,gypsies grabage,garbage +grabed,grabbed +grabing,grabbing gracefull,graceful gracefullly,gracefully gracefuly,gracefully @@ -11466,8 +22735,12 @@ gradualy,gradually graduaste,graduates graduatin,graduation graet,great +grafics,graphics grafield,garfield grafitti,graffiti +grahic,graphic +grahical,graphical +grahics,graphics grahpic,graphic grahpical,graphical grahpically,graphically @@ -11475,35 +22748,50 @@ grahpics,graphics grahpite,graphite graident,gradient grainte,granite +gramar,grammar +gramatically,grammatically grammarical,grammatical grammarically,grammatically +grammartical,grammatical grammaticaal,grammatical grammaticallity,grammatically grammaticaly,grammatically grammaticly,grammatical grammer,grammar +grammers,grammars grammitical,grammatical +granchildren,grandchildren grandchilden,grandchildren grandchilder,grandchildren grandchilderen,grandchildren grandchildern,grandchildren grandchilren,grandchildren graniet,granite +granilarity,granularity granolla,granola grantie,granite +granuality,granularity +granualtiry,granularity +granulatiry,granularity grapefriut,grapefruit grapefrukt,grapefruit +grapgics,graphics graphcially,graphically graphcis,graphics graphicaly,graphically graphiclly,graphically graphie,graphite graphis,graphics +grapic,graphic +grapical,graphical grapichs,graphics +grapics,graphics grappel,grapple grappnel,grapple grassrooots,grassroots grassrooters,grassroots +grat,great +gratefull,grateful gratificacion,gratification gratificaiton,gratification gratituous,gratuitous @@ -11524,10 +22812,15 @@ gravitaitonal,gravitational gravitatie,gravitate gravitatiei,gravitate gravitationnal,gravitational +grbber,grabber greande,grenade greandes,grenades +greate,greater,create,grate,great +greated,greater,grated,graded greatful,grateful +greatfull,grateful,gratefully greatfully,gratefully +greather,greater greenalnd,greenland greeneer,greener greenhoe,greenhouse @@ -11538,32 +22831,53 @@ greif,grief grenaders,grenades grenads,grenades greneer,greener +grephic,graphic +grestest,greatest greusome,gruesome greviances,grievances +greysacles,greyscales griaffe,giraffe gridles,griddles grieifng,griefing grievences,grievances grifeing,griefing +grigorian,gregorian grilfriend,girlfriend grilfriends,girlfriends grillig,grilling gringeworthy,cringeworthy grizzlay,grizzly grizzley,grizzly +grobal,global +grobally,globally +grometry,geometry +grooup,group +groouped,grouped +groouping,grouping +grooups,groups +grop,group,drop gropu,group +gropus,groups,gropes groubdbreaking,groundbreaking +groubpy,groupby groudnbreaking,groundbreaking +groupd,grouped +groupes,groups,grouped +groupt,grouped grpahic,graphic grpahical,graphical grpahically,graphically grpahics,graphics grpahite,graphite +grranted,granted +gruop,group +gruopd,grouped +gruops,groups gruseome,gruesome grwo,grow -guaduloupe,guadalupe -guadulupe,guadalupe -guage,gage +guaduloupe,guadalupe,guadeloupe +guadulupe,guadalupe,guadeloupe +guage,gage,gage guanatanmo,guantanamo guantamamo,guantanamo guantamano,guantanamo @@ -11577,8 +22891,11 @@ guantanomo,guantanamo guantonamo,guantanamo guaranted,guaranteed guaranteeds,guarantees +guaranteey,guaranty guarantes,guarantees guarantess,guarantees +guarantie,guarantee +guarbage,garbage guardain,guardian guardains,guardians guardiands,guardians @@ -11586,21 +22903,144 @@ guardianes,guardians guardianis,guardians guardias,guardians guardin,guardian +guared,guard,guarded +guareded,guarded +guareente,guarantee +guareented,guaranteed +guareentee,guarantee +guareenteed,guaranteed +guareenteeing,guaranteeing +guareentees,guarantees +guareenteing,guaranteeing +guareentes,guarantees +guareenty,guaranty +guarente,guarantee +guarented,guaranteed guarentee,guarantee guarenteed,guaranteed +guarenteede,guarantee +guarenteeded,guaranteed +guarenteedeing,guaranteeing +guarenteedes,guarantees +guarenteedy,guaranty +guarenteeing,guaranteeing +guarenteer,guarantee +guarenteerd,guaranteed +guarenteering,guaranteeing +guarenteers,guarantees guarentees,guarantees +guarenteing,guaranteeing +guarentes,guarantees +guarentie,guarantee +guarentied,guaranteed +guarentieing,guaranteeing +guarenties,guarantees +guarenty,guaranty +guarentyd,guaranteed +guarentying,guarantee +guarentyinging,guaranteeing +guarentys,guarantees +guarging,guarding guaridan,guardian guaridans,guardians +guarnante,guarantee +guarnanted,guaranteed +guarnantee,guarantee +guarnanteed,guaranteed +guarnanteeing,guaranteeing +guarnantees,guarantees +guarnanteing,guaranteeing +guarnantes,guarantees +guarnanty,guaranty +guarnate,guarantee +guarnated,guaranteed +guarnatee,guarantee guarnateed,guaranteed +guarnateee,guarantee +guarnateeed,guaranteed +guarnateeeing,guaranteeing +guarnateees,guarantees +guarnateeing,guaranteeing guarnatees,guarantees +guarnateing,guaranteeing +guarnates,guarantees +guarnatey,guaranty +guarnaty,guaranty +guarnete,guarantee +guarneted,guaranteed +guarnetee,guarantee +guarneteed,guaranteed +guarneteeing,guaranteeing +guarnetees,guarantees +guarneteing,guaranteeing +guarnetes,guarantees +guarnety,guaranty +guarnte,guarantee +guarnted,guaranteed +guarntee,guarantee +guarnteed,guaranteed +guarnteeing,guaranteeing +guarntees,guarantees +guarnteing,guaranteeing +guarntes,guarantees +guarnty,guaranty +guarrante,guarantee +guarranted,guaranteed +guarrantee,guarantee +guarranteed,guaranteed +guarranteeing,guaranteeing +guarrantees,guarantees +guarranteing,guaranteeing +guarrantes,guarantees +guarrantie,guarantee +guarrantied,guaranteed +guarrantieing,guaranteeing +guarranties,guarantees +guarranty,guaranty +guarrantyd,guaranteed +guarrantying,guaranteeing +guarrantys,guarantees +guarrente,guarantee +guarrented,guaranteed +guarrentee,guarantee +guarrenteed,guaranteed +guarrenteeing,guaranteeing +guarrentees,guarantees +guarrenteing,guaranteeing +guarrentes,guarantees +guarrenty,guaranty +guaruante,guarantee +guaruanted,guaranteed +guaruantee,guarantee +guaruanteed,guaranteed +guaruanteeing,guaranteeing +guaruantees,guarantees +guaruanteing,guaranteeing +guaruantes,guarantees +guaruanty,guaranty +guarunte,guarantee +guarunted,guaranteed +guaruntee,guarantee guarunteed,guaranteed +guarunteeing,guaranteeing guaruntees,guarantees +guarunteing,guaranteeing +guaruntes,guarantees +guarunty,guaranty +guas,gauss +guass,gauss +guassian,gaussian guatamala,guatemala guatamalan,guatemalan +gud,good +gude,guide,good guerrila,guerrilla guerrilas,guerrillas guerrillera,guerrilla +gueswork,guesswork guidence,guidance +guidline,guideline +guidlines,guidelines guilia,giulia guilio,giulio guiness,guinness @@ -11626,36 +23066,55 @@ guradians,guardians gurading,guarding gurantee,guarantee guranteed,guaranteed +guranteeing,guaranteeing gurantees,guarantees guresome,gruesome +gurrantee,guarantee gutiarist,guitarist gutiars,guitars guttaral,guttural gutteral,guttural +gylph,glyph gymanstics,gymnastics gymnasitcs,gymnastics gynmastics,gymnastics gypises,gypsies gyspies,gypsies +gziniflate,gzinflate +gziped,gzipped +haa,has habaeus,habeas +habbit,habit habeus,habeas +hability,ability habsbourg,habsburg +hace,have +hach,hatch,hack,hash +hachish,hackish hacthing,hatching +haders,headers,shaders,haters +hadling,handling +hadnler,handler +haeder,header haemorrage,haemorrhage haethen,heathen -haev,have +haev,have,heave hafltime,halftime +hahve,have,halve,half hailfax,halifax haircuit,haircut hairstlye,hairstyle hairsytle,hairstyle halarious,hilarious +hald,held halfiax,halifax halfitme,halftime +halfs,halves hallcuination,hallucination hallcuinations,hallucination hallicunation,hallucination hallicunations,hallucinations +hallowean,halloween halloweeen,halloween hallowen,halloween hallucenation,hallucination @@ -11673,6 +23132,7 @@ hallusinations,hallucinations halluzination,hallucination halluzinations,hallucinations halp,help +halpoints,halfpoints hambergers,hamburgers hambruger,hamburger hamburgare,hamburger @@ -11687,56 +23147,143 @@ hamburguers,hamburgers hamburgurs,hamburgers hamitlon,hamilton hamliton,hamilton +hammmer,hammer hamphsire,hampshire +hampster,hamster hamsphire,hampshire handbok,handbook handboook,handbook handcuffes,handcuffs handcufs,handcuffs +hande,handle,hand handedley,handedly handedlly,handedly handedy,handedly +handel,handle handelbars,handlebars -handeld,handled +handeld,handled,handheld handeldy,handedly +handeled,handled,handheld +handeler,handler +handeles,handles +handeling,handling +handels,handles +hander,handler +handfull,handful +handhake,handshake handicape,handicapped handicaped,handicapped handlade,handled handlare,handler handlebards,handlebars handledy,handedly +handleer,handler +handleing,handling +handlig,handling +handlling,handling handrwiting,handwriting +handsake,handshake +handshacke,handshake +handshackes,handshakes +handshacking,handshaking +handshage,handshake +handshages,handshakes +handshaging,handshaking +handshak,handshake +handshakng,handshaking +handshakre,handshake +handshakres,handshakes +handshakring,handshaking +handshaks,handshakes +handshale,handshake +handshales,handshakes +handshaling,handshaking +handshare,handshake +handshares,handshakes +handsharing,handshaking +handshk,handshake +handshke,handshake +handshkes,handshakes +handshking,handshaking +handshkng,handshaking +handshks,handshakes +handskake,handshake +handwirting,handwriting handwritng,handwriting handwritting,handwriting handycapped,handicapped +hanel,handle +hangig,hanging hanidcapped,handicapped +hanlde,handle +hanlded,handled hanlder,handler +hanlders,handlers +hanldes,handles +hanlding,handling +hanldle,handle +hanle,handle +hanled,handled +hanles,handles +hanling,handling hannbial,hannibal hannibl,hannibal +hanshake,handshake +hanshakes,handshakes +hansome,handsome hanuted,haunted haorder,hoarder haording,hoarding hapen,happen +hapend,happened +hapends,happens hapened,happened hapening,happening +hapenn,happen +hapenned,happened +hapenning,happening +hapenns,happens +hapens,happens hapmshire,hampshire -happend,happened +happaned,happened +happend,happened,happens,happen happended,happened happends,happens happenend,happened happenes,happens happenned,happened +happenning,happening +happennings,happenings +happenns,happens happilly,happily +happing,happening,happen happliy,happily +happne,happen +happnes,happens,happiness +happpen,happen +happpened,happened +happpening,happening +happpenings,happenings +happpens,happens harased,harassed harases,harasses harasment,harassment harasments,harassments harassement,harassment +harcode,hardcode,charcode +harcoded,hardcoded +harcodes,hardcodes,charcodes +harcoding,hardcoding +hardare,hardware hardend,hardened hardenend,hardened +hardocde,hardcode +hardward,hardware +hardwdare,hardware +hardwirted,hardwired hardwod,hardwood hardwoord,hardwood +harge,charge haricut,haircut haristyle,hairstyle harldine,hardline @@ -11748,21 +23295,41 @@ harrases,harasses harrasing,harassing harrasment,harassment harrasments,harassments +harrass,harass harrassed,harassed harrasses,harassed harrassing,harassing harrassment,harassment harrassments,harassments +harth,hearth harvasting,harvesting harvestgain,harvesting +harware,hardware +harwdare,hardware +hases,hashes +hashi,hash +hashs,hashes +hashses,hashes +hask,hash +hass,hash hatchig,hatching hatchign,hatching hatesink,heatsink hathcing,hatching hatian,haitian hauntig,haunting +hauty,haughty +hav,have,half +hava,have +havea,have +havee,have +haveing,having haversting,harvesting +havew,have haviest,heaviest +haynus,heinous +hazzle,hassle +hda,had hdinsight,hindsight headachs,headaches headahces,headaches @@ -11771,6 +23338,8 @@ headests,headsets headhpone,headphone headhpones,headphones headhsot,headshot +headle,handle +headong,heading headphoens,headphones headqaurters,headquarters headquarer,headquarter @@ -11778,10 +23347,12 @@ headquartes,headquarters headquater,headquarter headquatered,headquartered headquaters,headquarters +headrom,headroom,bedroom headseat,headset headses,headsets headshoot,headshot headshoots,headshot +heaer,header healither,healthier healtchare,healthcare healtheast,healthiest @@ -11793,7 +23364,7 @@ healthit,healthiest healthyest,healthiest heapdhone,headphone heapdhones,headphones -heared,heard +heared,heard,header hearhtstone,hearthstone heartbeart,heartbeat heartbeast,heartbeat @@ -11806,6 +23377,7 @@ hearthsone,hearthstone heartsthone,hearthstone heastink,heatsink heathern,heathen +heathy,healthy heatlhcare,healthcare heatskin,heatsink heaveny,heavenly @@ -11822,22 +23394,36 @@ hedeghog,hedgehog hedgehodge,hedgehog hedgehoog,hedgehog hedgehorg,hedgehog +hefer,heifer hegdehog,hedgehog heidelburg,heidelberg +heigest,highest +heigh,height,high heigher,higher -heighest,heights +heighest,heights,highest +heighit,height heighted,heightened +heighteen,eighteen heightend,heightened +heigt,height +heigth,height heigthened,heightened heigths,heights +heirachies,hierarchies heirachy,hierarchy +heirarchic,hierarchic +heirarchical,hierarchical +heirarchically,hierarchically +heirarchies,hierarchies heirarchy,hierarchy heiroglyphics,hieroglyphics heistant,hesitant heistate,hesitate heistation,hesitation +hel,help,hell,heal helathcare,healthcare helemts,helmets +helerps,helpers helicopers,helicopters helicopteros,helicopters helicoptor,helicopter @@ -11852,26 +23438,37 @@ helikopter,helicopter helikopters,helicopters hellfie,hellfire hellifre,hellfire +hellow,hello hellucination,hallucination hellucinations,hallucinations helluvva,helluva hellvua,helluva helment,helmet +heloer,helper +heloers,helpers +helpe,helper helpfull,helpful +helpfuly,helpfully helpped,helped hemingwary,hemingway hemingwavy,hemingway hemipshere,hemisphere hemipsheres,hemisphere hemishpere,hemisphere -hemishperes,hemisphere +hemishperes,hemisphere,hemispheres hemlets,helmets hemmorhage,hemorrhage +hemorage,hemorrhage hempishere,hemisphere +henc,hence +henderence,hindrance +hendler,handler henious,heinous heorics,heroics heorine,heroine -herad,heard +hepler,helper +herad,heard,hera +herat,heart herathstone,hearthstone heratige,heritage herclues,hercules @@ -11882,6 +23479,7 @@ herculeasy,hercules herculeees,hercules herculees,hercules herculeus,hercules +heree,here hererosexual,heterosexual heretosexual,heterosexual heriarchy,hierarchy @@ -11895,9 +23493,13 @@ heroices,heroics heroicos,heroics heroicus,heroics heronie,heroine +heros,heroes +herselv,herself hertiage,heritage +hertically,hectically hertzs,hertz herucles,hercules +hesiate,hesitate hesiman,heisman hesistant,hesitant hesistate,hesitate @@ -11910,36 +23512,93 @@ heteresexual,heterosexual heterosexal,heterosexual heterosexuella,heterosexual hetreosexual,heterosexual +hetrogeneous,heterogeneous +hetrogenous,heterogenous,heterogeneous +heuristc,heuristic +heuristcs,heuristics +heursitics,heuristics heveanly,heavenly +hevy,heavy +hexademical,hexadecimal +hexdecimal,hexadecimal hexidecimal,hexadecimal +hge,he +hiarchical,hierarchical +hiarchy,hierarchy +hiddden,hidden +hidded,hidden +hiddin,hidden,hiding +hidding,hiding,hidden +hiden,hidden +hiearchies,hierarchies +hiearchy,hierarchy hieght,height hieghtened,heightened hieghts,heights +hiena,hyena hienous,heinous hierachical,hierarchical hierachies,hierarchies hierachy,hierarchy +hierarachical,hierarchical +hierarachy,hierarchy +hierarchie,hierarchy hierarcical,hierarchical hierarcy,hierarchy +hierarhcical,hierarchical +hierarhcically,hierarchically +hierarhcies,hierarchies +hierarhcy,hierarchy +hierchy,hierarchy hieroglph,hieroglyph hieroglphs,hieroglyphs hiesman,heisman +hietus,hiatus +higeine,hygiene higer,higher higest,highest highalnder,highlander +highe,high,higher,highs +highes,highest,highs highlane,highlander highlighed,highlighted highlighing,highlighting highlightning,highlighting +highligjt,highlight +highligjted,highlighted +highligjtes,highlights +highligjting,highlighting +highligjts,highlights +highligt,highlight highligted,highlighted highligthing,highlighting +highligting,highlighting +highligts,highlights highloader,highlander highpander,highlander highschol,highschool highscholl,highschool highschoool,highschool highshcool,highschool +hight,height,high +highter,higher +hightest,highest +hightlight,highlight +hightlighted,highlighted +hightlighting,highlighting +hightlights,highlights +hights,height +higlight,highlight +higlighted,highlighted +higlighting,highlighting +higlights,highlights +higly,highly +higth,height higway,highway +hilight,highlight +hilighted,highlighted +hilighting,highlighting +hilights,highlights hillarious,hilarious himselv,himself hinderance,hindrance @@ -11953,15 +23612,22 @@ hindusim,hinduism hinudism,hinduism hipocritical,hypocritical hipopotamus,hippopotamus +hipotetical,hypothetical hipothetical,hypothetical hipothetically,hypothetically hipsanics,hispanics hipsterest,hipsters hiptser,hipster hiptsers,hipsters +hirachy,hierarchy +hirarchies,hierarchies +hirarchy,hierarchy +hirarcies,hierarchies hirearchy,hierarchy +hirearcy,hierarchy hirsohima,hiroshima hismelf,himself +hisory,history hispancis,hispanics hispanicos,hispanics hispanicus,hispanics @@ -11972,7 +23638,9 @@ histarical,historical histarically,historically histerical,historical histerically,historically +histgram,histogram histocompatability,histocompatibility +histori,history,historic historiaan,historians historicaly,historically historicans,historians @@ -11983,27 +23651,50 @@ historiens,histories historietas,histories historinhas,historians historisch,historic +historyan,historian +historyans,historians +historycal,historical +historycally,historically +historycaly,historically +histroian,historian +histroians,historians histroic,historic +histroical,historical +histroically,historically +histroicaly,historically +histroies,histories +histroy,history +histry,history hitboxers,hitboxes hitboxs,hitboxes +hitogram,histogram +hiygeine,hygiene +hnalder,handler hodlings,holdings +hoeks,hoax hoemopathy,homeopathy hoenstly,honestly hoepfully,hopefully +hoever,however hoilday,holiday hoildays,holidays +hokay,okay hokpins,hopkins holdiay,holiday holdiays,holidays holdins,holdings holf,hold +holliday,holiday +hollowcost,holocaust hollywod,hollywood hollywoood,hollywood holocasut,holocaust holocuast,holocaust +homapage,homepage homecomeing,homecoming homecomming,homecoming homecuming,homecoming +homegeneous,homogeneous homelesness,homelessness homelessess,homelessness homeoapthy,homeopathy @@ -12034,6 +23725,13 @@ homogeneos,homogeneous homogenes,homogeneous homogeneus,homogeneous homogenious,homogeneous +homogeniously,homogeneously +homogenity,homogeneity +homogenius,homogeneous +homogeniusly,homogeneously +homogenoues,homogeneous +homogenous,homogeneous +homogenously,homogeneously homogenuous,homogeneous homophibia,homophobia homophibic,homophobic @@ -12060,27 +23758,48 @@ honeymon,honeymoon honeymooon,honeymoon honory,honorary honsetly,honestly +hoook,hook +hoooks,hooks +hootsba,hutzpa +hopefull,hopeful,hopefully +hopefulle,hopefully hopefullly,hopefully +hopefullt,hopefully +hopefullu,hopefully hopefuly,hopefully +hopeing,hoping hopeleslly,hopelessly hopelessely,hopelessly hopelessley,hopelessly hopelessy,hopelessly +hopful,hopeful +hopfull,hopeful,hopefully +hopfully,hopefully hopkings,hopkins +hopmepage,homepage +hopmepages,homepages +hoppefully,hopefully hopsital,hospital hopsitality,hospitality hopsitalized,hospitalized hopsitals,hospitals +hopyfully,hopefully horader,hoarder horading,hoarding +horicontal,horizontal +horicontally,horizontally +horinzontal,horizontal horishima,hiroshima horisontal,horizontal horisontally,horizontally horizantal,horizontal horizantally,horizontally +horizntal,horizontal +horizonal,horizontal horizonatal,horizontal horizones,horizons horizontaal,horizontal +horizontale,horizontal horizontallly,horizontally horizontaly,horizontally horizontes,horizons @@ -12088,6 +23807,8 @@ horizonts,horizons horiztonal,horizontal horiztonally,horizontally horozontally,horizontally +horphan,orphan +horrable,horrible horrendeous,horrendous horrendeus,horrendous horrendious,horrendous @@ -12097,7 +23818,12 @@ horriblely,horribly horribley,horribly horriblly,horribly horrifing,horrifying +horyzontally,horizontally horzions,horizons +horziontal,horizontal +horziontally,horizontally +horzontal,horizontal +horzontally,horizontally hosited,hoisted hositlity,hostility hospitales,hospitals @@ -12112,38 +23838,73 @@ hospotality,hospitality hosptial,hospital hosptialized,hospitalized hosptials,hospitals +hostanme,hostname hosteles,hostels hosthot,hotshot hostiliy,hostility hostles,hostels +hostorical,historical +hostories,histories +hostory,history hostpot,hotspot +hostspot,hotspot +hostspots,hotspots hothsot,hotshot +hotizontal,horizontal +hotname,hostname hotpsot,hotspot hotshoot,hotshot hotsopt,hotspot hotsport,hotspot +hould,hold,should hounour,honour +houres,hours hourgalss,hourglass hourlgass,hourglass +housand,thousand househols,households househoulds,households -housr,hours +houskeeping,housekeeping +housr,hours,house +hovever,however +hovewer,however +howerver,however +howeverm,however howver,however +hradware,hardware +hradwares,hardwares +hrlp,help +hrlped,helped +hrlper,helper +hrlpers,helpers +hrlping,helping +hrlps,helps +hrough,through +hsa,has hseldon,sheldon +hsell,shell +hsi,his hsitorians,historians +hsotname,hostname +hsould,should hstory,history hsyteria,hysteria +htacccess,htaccess htaching,hatching -hten,then -htere,there +hte,the +hten,then,hen,the +htere,there,here htey,they htiboxes,hitboxes htikn,think hting,thing htink,think htis,this +htmp,html +htting,hitting huanted,haunted huanting,haunting +hueristic,heuristic hullucination,hallucination hullucinations,hallucinations humanaties,humanities @@ -12162,7 +23923,9 @@ humanoind,humanoid humantiarian,humanitarian humantiy,humanity humants,humanist -humerous,humorous +humber,number +humer,humor,humor +humerous,humorous,humerus humiditiy,humidity humidiy,humidity humiliatin,humiliation @@ -12185,11 +23948,18 @@ hunderd,hundred hunderds,hundreds hundread,hundred hundres,hundreds +hundret,hundred,hundreds +hundreths,hundredths +hundrets,hundreds hungarin,hungarian hungray,hungary +hungs,hangs,hung hunman,human +hunrgy,hungry huntmsan,huntsman hurdels,hurdles +huricane,hurricane +huristic,heuristic hurldes,hurdles hurriance,hurricane hurricaines,hurricanes @@ -12201,17 +23971,21 @@ hurricans,hurricanes hurriganes,hurricanes hurrikanes,hurricanes hurrycanes,hurricanes +hurse,hearse,nurse husban,husband husbandos,husbands husbans,husbands +hussel,hustle,mussel hutnsman,huntsman hvae,have hvaing,having -hvea,have +hve,have +hvea,have,heave hweaton,wheaton hwihc,which hwile,while hwole,whole +hybernate,hibernate hybirds,hybrids hybrides,hybrids hybridus,hybrids @@ -12220,23 +23994,40 @@ hydorgen,hydrogen hydraluic,hydraulic hydratin,hydration hydregon,hydrogen +hydrolic,hydraulic +hydrolics,hydraulics hydropile,hydrophile hydropilic,hydrophilic hydropobe,hydrophobe hydropobic,hydrophobic hydrualic,hydraulic +hyerarchy,hierarchy +hyerlink,hyperlink hygeine,hygiene +hygene,hygiene +hygenic,hygienic hygience,hygiene hygienne,hygiene +hygine,hygiene +hyjack,hijack +hyjacking,hijacking hyopcrite,hypocrite hyopthetical,hypothetical hyopthetically,hypothetically hypathetical,hypothetical hypathetically,hypothetically hypcorite,hypocrite +hypen,hyphen +hypenate,hyphenate +hypenated,hyphenated +hypenates,hyphenates +hypenating,hyphenating +hypenation,hyphenation +hypens,hyphens hyperbel,hyperbole hyperbolie,hyperbole hyperbollic,hyperbolic +hyperboly,hyperbole hyperbrophy,hypertrophy hyperlobic,hyperbolic hyperlogic,hyperbolic @@ -12247,6 +24038,7 @@ hypertrohpy,hypertrophy hypertrohy,hypertrophy hypertrophey,hypertrophy hypertropy,hypertrophy +hypervior,hypervisor hypethetical,hypothetical hypethetically,hypothetically hyphotesis,hypothesis @@ -12272,8 +24064,12 @@ hypocrytical,hypocritical hypokrites,hypocrites hyponsis,hypnosis hyporcite,hypocrite +hyposeses,hypotheses +hyposesis,hypothesis hypotehtical,hypothetical hypotehtically,hypothetically +hypoteses,hypotheses +hypotesis,hypothesis hypotethical,hypothetical hypotethically,hypothetically hypothecis,hypothesis @@ -12291,6 +24087,13 @@ hypothosis,hypothesis hyprocisy,hypocrisy hyprocite,hypocrite hyprocites,hypocrites +hypter,hyper +hyptothetical,hypothetical +hyptothetically,hypothetically +hypvervisor,hypervisor +hypvervisors,hypervisors +hypvisor,hypervisor +hypvisors,hypervisors hyrbids,hybrids hyrdation,hydration hyrdaulic,hydraulic @@ -12306,6 +24109,8 @@ hystericly,hysterical hysteriia,hysteria hysteriska,hysteria hystorically,hysterically +iamge,image +ibrary,library ibuprofein,ibuprofen ibuprofine,ibuprofen iburpofen,ibuprofen @@ -12313,9 +24118,13 @@ iceforg,icefrog icefrong,icefrog icelandinc,icelandic icelings,ceilings +icesickle,icicle icleandic,icelandic +icluding,including iconclastic,iconoclastic icongnito,incognito +iconifie,iconify +idae,idea idaeidae,idea idaes,ideas idealisim,idealism @@ -12326,18 +24135,38 @@ idealistisch,idealistic idealogies,ideologies idealogy,ideology idealsim,idealism +idefinite,indefinite +idelogy,ideology +idendifier,identifier +idenfifier,identifier idenfity,identify idenitfy,identify +idenitify,identify +identation,indentation +identcial,identical +identiable,identifiable +idential,identical identicial,identical +identidier,identifier +identifaction,identification +identifcation,identification +identifeir,identifier +identifeirs,identifiers +identifer,identifier +identifers,identifiers identifible,identifiable +identificable,identifiable identificacion,identification identificaiton,identification identificativo,identification identificato,identification identificaton,identification +identifictaion,identification +identifieer,identifier identifierad,identified identifieras,identifies identifikation,identification +identifing,identifying identifiy,identify identifyable,identifiable identifyed,identified @@ -12345,6 +24174,11 @@ identite,identities identitets,identities identitites,identities identitties,identities +identiy,identify,identity +identtation,indentation +identties,identities +identtifier,identifier +identty,identity ideolagies,ideologies ideoligically,ideologically ideoligies,ideologies @@ -12361,16 +24195,95 @@ ideologiset,ideologies ideologisk,ideologies ideologiske,ideologies ideolouges,ideologies +ideosyncracies,ideosyncrasies ideosyncratic,idiosyncratic -idesa,ideas +idesa,ideas,ides +idetifies,identifies +idicate,indicate +idicated,indicated +idicates,indicates +idicating,indicating +idices,indices idiologically,ideologically idiosynchracies,idiosyncrasies +idiosyncracies,idiosyncrasies idiosyncracy,idiosyncrasy +idividual,individual +idividually,individually +idividuals,individuals +iechart,piechart ierland,ireland +ifself,itself ignitin,ignition +ignoded,ignored +ignonre,ignore +ignora,ignore ignorat,ignorant +ignord,ignored +ignoreing,ignoring +ignorence,ignorance +ignorgable,ignorable +ignorgd,ignored +ignorge,ignore +ignorged,ignored +ignorgg,ignoring +ignorgig,ignoring +ignorging,ignoring +ignorgs,ignores +ignormable,ignorable +ignormd,ignored +ignorme,ignore +ignormed,ignored +ignormg,ignoring +ignormig,ignoring +ignorming,ignoring +ignorms,ignores +ignornable,ignorable ignornace,ignorance +ignornd,ignored +ignorne,ignore +ignorned,ignored +ignorng,ignoring +ignornig,ignoring +ignorning,ignoring +ignorns,ignores +ignorrable,ignorable +ignorrd,ignored +ignorre,ignore +ignorred,ignored +ignorrg,ignoring +ignorrig,ignoring +ignorring,ignoring +ignorrs,ignores +ignors,ignores +ignortable,ignorable +ignortd,ignored +ignorte,ignore +ignorted,ignored +ignortg,ignoring +ignortig,ignoring +ignorting,ignoring +ignorts,ignores +ignory,ignore +ignroed,ignored +ignroing,ignoring +igoned,ignored +igonorando,ignorando +igonore,ignore +igore,ignore +igored,ignored +igores,ignores +igoring,ignoring ihaca,ithaca +ihs,his +iif,if +iimmune,immune +iinclude,include +iland,island +ileagle,illegal +ilegal,illegal +ilegle,illegal +iligal,illegal illegales,illegals illegalest,illegals illegalis,illegals @@ -12390,15 +24303,18 @@ illegitimt,illegitimate illegitmate,illegitimate illegsl,illegals illess,illness +illgal,illegal illiegal,illegal +illigal,illegal illigetimate,illegitimate +illigitament,illegitimate illigitemate,illegitimate illimunati,illuminati illinios,illinois illinoians,illinois illinos,illinois illionis,illinois -illistrate,illiterate +illistrate,illiterate,illustrate illistration,illustration illistrations,illustrations illitarate,illiterate @@ -12442,6 +24358,7 @@ illustraion,illustration illustraitor,illustrator illustrant,illustrate illustrare,illustrate +illustrasion,illustration illustrater,illustrator illustratie,illustrate illustraties,illustrate @@ -12454,11 +24371,20 @@ illution,illusion ilness,illness ilogical,illogical ilterate,literate +iluminate,illuminate +iluminated,illuminated +iluminates,illuminates +ilumination,illumination +iluminations,illuminations +ilustrate,illustrate +ilustrated,illustrated +ilustration,illustration imablanced,imbalanced imablances,imbalances imaganative,imaginative imaganitive,imaginative imagenary,imaginary +imaghe,image imagin,imagine imaginacion,imagination imaginatie,imaginative @@ -12466,11 +24392,15 @@ imaginatiei,imaginative imaginating,imagination imaginativo,imagination imaginaton,imagination -imaginery,imaginary +imaginery,imaginary,imagery imaginitave,imaginative imaginitve,imaginative -imanent,eminent +imanent,eminent,imminent +imapct,impact +imapcted,impacted +imapcting,impacting imapcts,impacts +imapge,image imapired,impaired imaptient,impatient imbalanaced,imbalanced @@ -12478,31 +24408,77 @@ imbalanaces,imbalances imbalancers,imbalances imbalenced,imbalanced imbalences,imbalances +imbaress,embarrass +imblance,imbalance +imbrase,embrace +imcoming,incoming +imcomming,incoming +imcompatibility,incompatibility imcompatible,incompatible imcompetence,incompetence imcomplete,incomplete imcomprehensible,incomprehensible +imedatly,immediately +imedialy,immediately +imediate,immediate imediately,immediately +imediatly,immediately imense,immense imexperience,inexperience +imfamus,infamous +imgage,image imgrants,migrants -imigrant,emigrant -imigrated,emigrated -imigration,emigration -iminent,eminent +imidiately,immediately +imigrant,emigrant,immigrant +imigrate,immigrate,emigrate +imigrated,emigrated,immigrated +imigration,emigration,immigration +imilar,similar +iminent,eminent,imminent,immanent +imlement,implement +imlementation,implementation +imlemented,implemented +imlementing,implementing +imlements,implements +imlicit,implicit +imlicitly,implicitly +imliment,implement +imlimentation,implementation +imlimented,implemented +imlimenting,implementing +imliments,implements imlpementation,implementations +immadiate,immediate +immadiately,immediately +immadiatly,immediately immaturaty,immaturity immatureity,immaturity immaturety,immaturity immboile,immobile +immeadiate,immediate +immeadiately,immediately +immedaite,immediate +immedate,immediate +immedately,immediately immedeately,immediately immedeatly,immediately +immedially,immediately +immedialty,immediately +immediantely,immediately immediantly,immediately +immediated,immediate,immediately immediatelly,immediately immediatley,immediately +immediatlly,immediately immediatly,immediately +immediatlye,immediately immedietely,immediately immedietly,immediately +immeditaly,immediately +immeditately,immediately +immeidate,immediate +immeidately,immediately +immenantly,eminently immenint,imminent immenseley,immensely immensley,immensely @@ -12511,9 +24487,12 @@ immersie,immerse immersve,immerse immesnely,immensely immidately,immediately +immidatly,immediately immideately,immediately immidiate,immediate +immidiatelly,immediately immidiately,immediately +immidiatly,immediately immigraiton,immigration immigrantes,immigrants immigranti,immigration @@ -12524,6 +24503,8 @@ immitate,imitate immitated,imitated immitating,imitating immitator,imitator +immmediate,immediate +immmediately,immediately immobilie,immobile immobilien,immobile immobilier,immobile @@ -12545,20 +24526,54 @@ immortalty,immortality immortaly,immortality immortas,immortals immserive,immersive +immuniy,immunity immunosupressant,immunosuppressant +immutible,immutable +imolicit,implicit +imolicitly,implicitly +imort,import +imortable,importable +imorted,imported +imortes,imports +imorting,importing +imorts,imports +imovable,immovable impactes,impacts impactos,impacts impaitent,impatient imparied,impaired imparital,impartial impartirla,impartial +impcat,impact +impcated,impacted +impcating,impacting +impcats,impacts impecabbly,impeccably impeccabile,impeccable impeccible,impeccable impeckable,impeccable impedence,impedance +impeed,impede +impelement,implement +impelementation,implementation +impelemented,implemented +impelementing,implementing +impelements,implements +impelentation,implementation +impelment,implement impelmentation,implementations impelments,implements +impement,implement +impementaion,implementation +impementaions,implementations +impementated,implemented +impementation,implementation +impementations,implementations +impemented,implemented +impementing,implementing +impementling,implementing +impementor,implementer +impements,implements imperailist,imperialist imperavi,imperative imperealist,imperialist @@ -12566,6 +24581,7 @@ imperetive,imperative imperfactions,imperfections imperfectionists,imperfections imperfet,imperfect +imperiaal,imperial imperialfist,imperialist imperialims,imperialism imperialisim,imperialism @@ -12580,6 +24596,11 @@ imperitave,imperative imperitive,imperative impersinating,impersonating impersonationg,impersonating +impiled,implied +implace,inplace +implament,implement +implamentation,implementation +implamented,implemented implamenting,implementing implaments,implements implantase,implants @@ -12589,28 +24610,111 @@ implausbile,implausible implausble,implausible implausibe,implausible implausibile,implausible +implcit,implicit implecations,implications -implemenet,implements +implemantation,implementation +implemataion,implementation +implemataions,implementations +implemememnt,implement +implemememntation,implementation +implemement,implement +implemementation,implementation +implemementations,implementations +implememented,implemented +implemementing,implementing +implemements,implements +implememetation,implementation +implememntation,implementation +implememt,implement +implememtation,implementation +implememtations,implementations +implememted,implemented +implememting,implementing +implememts,implements +implemen,implement +implemenatation,implementation +implemenation,implementation +implemenationa,implementation +implemenationd,implementation +implemenations,implementations +implemencted,implemented +implemend,implement +implemends,implements +implemened,implemented +implemenet,implements,implement +implemenetaion,implementation +implemenetaions,implementations +implemenetation,implementation +implemenetations,implementations +implemenetd,implemented +implemeneted,implemented +implemeneter,implementer +implemeneting,implementing +implemenetions,implementations +implemenets,implements +implemenrt,implement implementacion,implementation implementaciones,implementations +implementaed,implemented implementaion,implementation +implementaions,implementations implementaiton,implementation implementaitons,implementations +implementantions,implementations implementas,implements implementase,implements implementasi,implements -implementatin,implementations -implementating,implementation +implementastion,implementation +implementataion,implementation +implementatation,implementation +implementated,implemented +implementates,implements +implementatin,implementations,implementation,implementing +implementating,implementation,implementing implementatino,implementations +implementatins,implementations implementationen,implementations implementationer,implementations +implementatition,implementation implementato,implementation +implementatoin,implementation +implementatoins,implementations +implementatoion,implementation +implementaton,implementation +implementator,implementer +implementators,implementers +implementattion,implementation +implementd,implemented +implemente,implement,implemented implementes,implements +implementet,implemented implementig,implementing +implemention,implementation implementos,implements -implemet,implements -implemetnation,implementations +implementtaion,implementation +implemet,implements,implement +implemetation,implementation +implemetations,implementations +implemeted,implemented +implemeting,implementing +implemetnation,implementations,implementation +implemets,implements +implemnt,implement +implemntation,implementation +implemntations,implementations +implemtation,implementation +implemtentation,implementation +impleneted,implemented +implenment,implement +implenmentation,implementation +implent,implement implentation,implementation +implentations,implementations +implented,implemented +implenting,implementing +implentors,implementers +implents,implements +impletment,implement implicacion,implication implicati,implicit implicatia,implicit @@ -12621,10 +24725,13 @@ implicetly,implicitly impliciet,implicit impliciete,implicit implicilty,implicitly +implicite,implicit,implicitly implicitely,implicitly implicitily,implicitly +implicitley,implicitly implicity,implicitly implict,implicit +implictly,implicitly implikation,implication implimenation,implementation impliment,implement @@ -12632,7 +24739,26 @@ implimentation,implementation implimentations,implementations implimented,implemented implimenting,implementing +implimention,implementation +implimentions,implementations +implimentor,implementor impliments,implements +implmenet,implement +implmenetaion,implementation +implmenetaions,implementations +implmenetation,implementation +implmenetations,implementations +implmenetd,implemented +implmeneted,implemented +implmeneter,implementer +implmeneting,implementing +implmenets,implements +implment,implement +implmentation,implementation +implmentations,implementations +implmented,implemented +implmenting,implementing +implments,implements imploed,implode implosed,implode imploys,employs @@ -12641,19 +24767,30 @@ impluses,impulses implusive,impulsive impolde,implode imporbable,improbable +imporing,importing +imporove,improve +imporoved,improved +imporovement,improvement +imporovements,improvements +imporoves,improves +imporoving,improving imporper,improper importamt,important importanly,importantly importantce,importance importanty,importantly importas,imports +importat,important importd,imported importen,importance importence,importance importend,imported +importent,important importently,importantly importerad,imported importes,imports +importnt,important +imporv,improve,improv imporve,improve imporved,improved imporvement,improvement @@ -12661,6 +24798,8 @@ imporvements,improvements imporves,improves imporving,improving imporvised,improvised +imporvment,improvement +imposible,impossible impossable,impossible impossbily,impossibly impossibal,impossibly @@ -12670,22 +24809,39 @@ impossibile,impossible impossibillity,impossibility impossibilty,impossibility impossibily,impossibly +impossiblble,impossible impossiblely,impossibly impossibley,impossibly impossiblity,impossibly impossiblly,impossibly impossibry,impossibly impossibul,impossibly +impot,import +impotr,import,importer +impotrt,import,imported,importer +impove,improve +impoved,improved +impovement,improvement +impovements,improvements impoverised,impoverished impovershied,impoverished impoversihed,impoverished +impoves,improves +impoving,improving +impplement,implement +impplementating,implementing +impplementation,implementation +impplemented,implemented impractial,impractical impracticle,impractical impreative,imperative imprefect,imperfect imprefection,imperfections imprefections,imperfections +impremented,implemented +impres,impress impresison,impressions +impresive,impressive impresonating,impersonating impressario,impresario impressin,impressions @@ -12698,14 +24854,40 @@ imprisonned,imprisoned improbabe,improbable improbabil,improbable improbabile,improbable +improbe,improve +improbement,improvement +improbements,improvements +improbes,improves improbible,improbable +improbing,improving +improbment,improvement +improbments,improvements +improof,improve +improofement,improvement +improofing,improving +improofment,improvement +improofs,improves +improove,improve +improoved,improved +improovement,improvement +improovements,improvements +improoves,improves +improoving,improving +improovment,improvement +improovments,improvements impropable,improbable +impropely,improperly impropre,improper improsined,imprisoned improsoned,imprisoned improsonment,imprisonment +improtant,important improtantly,importantly improted,imported +improvemen,improvement +improvemenet,improvement +improvemenets,improvements +improvemens,improvements improvemnt,improvement improvemnts,improvements improvents,improves @@ -12714,6 +24896,9 @@ improviserad,improvised improvished,improvised improvision,improvisation improvized,improvised +improvmenet,improvement +improvmenets,improvements +improvment,improvement improvments,improvements imprsioned,imprisoned impules,impulse @@ -12723,6 +24908,8 @@ impulsivley,impulsive impusle,impulse impusles,impulses impuslive,impulsive +imput,input +imrovement,improvement imrpove,improve imrpoved,improved imrpovement,improvement @@ -12733,18 +24920,25 @@ imrpovised,improvised imtimidating,intimidating imtimidation,intimidation inablility,inability +inacccessible,inaccessible +inaccesible,inaccessible inaccesibles,inaccessible inaccessable,inaccessible inaccessbile,inaccessible inaccessble,inaccessible inaccessibile,inaccessible inaccruate,inaccurate +inaccuraccies,inaccuracies +inaccuraccy,inaccuracy inaccuraces,inaccuracies inaccurasies,inaccuracies inaccuraties,inaccuracies inaccuricies,inaccuracies inaccurrate,inaccurate inacuraccies,inaccuracies +inacurate,inaccurate +inacurracies,inaccuracies +inacurrate,inaccurate inadaquate,inadequate inadaquete,inadequate inadecuate,inadequate @@ -12765,6 +24959,8 @@ inadvertenly,inadvertently inagurated,inaugurated inaguration,inauguration inahbitants,inhabitants +inaktively,inactively +inalid,invalid inapporpriate,inappropriate inapporpriately,inappropriately inappropiate,inappropriate @@ -12772,6 +24968,7 @@ inappropirate,inappropriate inappropraite,inappropriate inappropraitely,inappropriately inapproprate,inappropriate +inappropreate,inappropriate inappropriae,inappropriately inappropriatelly,inappropriately inappropriatley,inappropriately @@ -12779,15 +24976,21 @@ inappropriatly,inappropriately inappropriet,inappropriately inapproprietly,inappropriately inaproppriate,inappropriate +inate,innate inattractive,unattractive inaugures,inaugurates +inavlid,invalid inbalance,imbalance inbalanced,imbalanced +inbed,imbed +inbedded,imbedded inbeetwen,inbetween inbelievable,unbelievable inbetweeen,inbetween inbetwen,inbetween inbewteen,inbetween +inbility,inability +incalid,invalid incarantion,incarnation incarcaration,incarceration incarcelated,incarcerated @@ -12799,13 +25002,20 @@ incarnato,incarnation incarnaton,incarnation incarserated,incarcerated incarseration,incarceration +incatation,incantation +incatations,incantations +incative,inactive incedentally,incidentally +incementally,incrementally incentivare,incentive incentivate,incentive incentiveise,incentives incentivice,incentive incentivies,incentives incentivos,incentives +incerase,increase +incerased,increased +incerasing,increasing incerceration,incarceration incestigator,investigator incgonito,incognito @@ -12818,47 +25028,96 @@ incidentially,incidentally incidently,incidentally incidentul,incidental inclanation,inclination +inclding,including incldue,include +incldued,included +incldues,includes inclenation,inclination inclinacion,inclination inclinaison,inclination inclinato,inclination inclince,incline inclinde,incline +inclode,include inclreased,increased includ,include +includea,include includeds,includes +includee,include +includied,included +includig,including +includign,including includng,including +inclue,include +inclued,included +inclues,includes +incluging,including +incluide,include +incluing,including incluse,includes +inclused,included +inclusinve,inclusive +incmrement,increment incoginto,incognito incognitio,incognito incognition,incognito +incoherance,incoherence +incoherancy,incoherency incoherant,incoherent +incoherantly,incoherently incoherrent,incoherent incohorent,incoherent +incomapatibility,incompatibility +incomapatible,incompatible incomaptible,incompatible +incombatibilities,incompatibilities +incombatibility,incompatibility +incomfort,discomfort,uncomfortable incomfortable,uncomfortable incomfortably,uncomfortably +incomming,incoming +incommplete,incomplete incomparible,incompatible +incompatabable,incompatible +incompatabiity,incompatibility incompatabile,incompatible incompatabilities,incompatibilities incompatability,incompatibility +incompatabillity,incompatibility +incompatabilty,incompatibility +incompatabily,incompatibility incompatable,incompatible +incompatablie,incompatible,incompatibly +incompatablility,incompatibility incompatablities,incompatibilities +incompatablitiy,incompatibility incompatablity,incompatibility +incompatably,incompatibly +incompataibility,incompatibility +incompataible,incompatible +incompataility,incompatibility +incompatatbility,incompatibility +incompatatble,incompatible +incompatatible,incompatible +incompatbility,incompatibility incompatble,incompatible incompatent,incompetent +incompatiability,incompatibility incompatiable,incompatible incompatibil,incompatible incompatibile,incompatible +incompatibilies,incompatibilities incompatiblities,incompatibilities incompatiblity,incompatibility incompetance,incompetence incompetant,incompetent +incompete,incomplete incompetente,incompetence incompetentence,incompetence incompitable,incompatible incompitent,incompetent +incompleate,incomplete +incompleete,incomplete incompotent,incompetent incomprehencible,incomprehensible incomprehendible,incomprehensible @@ -12870,6 +25129,7 @@ incomprehinsible,incomprehensible incomprihensible,incomprehensible incomptable,incompatible incomptetent,incompetent +incomptible,incompatible inconcequential,inconsequential inconciderate,inconsiderate inconcistencies,inconsistencies @@ -12877,7 +25137,10 @@ inconcistency,inconsistency inconcistent,inconsistent inconditional,unconditional inconditionally,unconditionally +inconfort,discomfort,uncomfortable +inconfortable,uncomfortable incongito,incognito +inconisistent,inconsistent inconprehensible,incomprehensible inconsciously,unconsciously inconsecuential,inconsequential @@ -12889,20 +25152,32 @@ inconsequentual,inconsequential inconsiderant,inconsiderate inconsiquential,inconsequential inconsisent,inconsistent +inconsisently,inconsistently +inconsisntency,inconsistency inconsistance,inconsistency inconsistancies,inconsistencies inconsistancy,inconsistency inconsistant,inconsistent inconsistecy,inconsistency +inconsisten,inconsistent inconsistencias,inconsistencies -inconsistenly,inconsistency +inconsistend,inconsistent +inconsistendly,inconsistently +inconsistendt,inconsistent +inconsistendtly,inconsistently +inconsistenly,inconsistency,inconsistently inconsistensies,inconsistencies inconsistensy,inconsistency inconsistentcies,inconsistencies inconsistentcy,inconsistency +inconsistented,inconsistent inconsistenties,inconsistencies inconsistenty,inconsistency -inconsisteny,inconsistency +inconsisteny,inconsistency,inconsistent +inconsitant,inconsistent +inconsitency,inconsistency +inconsitent,inconsistent +inconstent,inconsistent,inconstant inconstitutional,unconstitutional incontrollably,uncontrollably inconveinence,inconvenience @@ -12914,18 +25189,44 @@ inconveniente,inconvenience inconveniet,inconvenient inconvenince,inconvenience inconventional,unconventional +inconvertable,inconvertible inconvienence,inconvenience inconvienenced,inconvenience inconvienent,inconvenient +inconvienience,inconvenience +inconvienient,inconvenient +inconvineance,inconvenience +inconvineances,inconveniences +inconvinence,inconvenience +inconvinences,inconveniences +inconviniance,inconvenience +inconviniances,inconveniences +inconvinience,inconvenience +inconviniences,inconveniences +inconviniency,inconvenience +inconviniencys,inconveniences +incooperates,incorporates +incoperate,incorporate +incoperated,incorporated +incoperates,incorporates +incoperating,incorporating +incoporate,incorporate +incoporated,incorporated +incoporates,incorporates +incoporating,incorporating incorect,incorrect incorectly,incorrectly +incoropate,incorporate +incoropates,incorporates incoroporated,incorporated incoroprate,incorporate incorparate,incorporate incorparated,incorporated +incorparates,incorporates incorparating,incorporating incorperate,incorporate incorperated,incorporated +incorperates,incorporates incorperating,incorporating incorperation,incorporation incorporare,incorporate @@ -12935,15 +25236,25 @@ incorportate,incorporate incorported,incorporated incorprates,incorporates incorproate,incorporated +incorreclty,incorrectly incorrecly,incorrectly incorrecty,incorrectly +incorreect,incorrect +incorreectly,incorrectly +incorrent,incorrect +incorret,incorrect incorretly,incorrectly incorruptable,incorruptible +incosistent,inconsistent +incosistente,inconsistent incpetion,inception incramental,incremental incramentally,incrementally incraments,increments increadible,incredible +increading,increasing +increament,increment +increas,increase incredable,incredible incredably,incredibly incrediable,incredible @@ -12954,8 +25265,14 @@ incredibily,incredibly incrediblely,incredibly incredibley,incredibly incrediby,incredibly +incremantal,incremental +incremeantal,incremental incrememnts,increments +incremenet,increment +incremenetd,incremented +incremeneted,incremented incremenets,increments +incrementall,incremental,incrementally incrementarla,incremental incrementarlo,incremental incrementas,increments @@ -12963,18 +25280,51 @@ incrementers,increments incremential,incremental incremently,incremental incrementos,increments +incremet,increment incremetal,incremental +incremeted,incremented +incremnet,increment +increse,increase +incresed,increased +increses,increases +incresing,increasing +incrfemental,incremental incrimental,incremental incriments,increments +incrmenet,increment +incrmenetd,incremented +incrmeneted,incremented +incrment,increment +incrmental,incremental +incrmentally,incrementally +incrmented,incremented +incrmenting,incrementing +incrments,increments incrompehensible,incomprehensible +inctance,instance inctroduce,introduce inctroduced,introduced +incude,include +incuded,included +incudes,includes incuding,including +inculde,include inculded,included +inculdes,includes inculding,including incunabla,incunabula +incure,incur +incurruptable,incorruptible +incurruptible,incorruptible +incvalid,invalid indains,indians indavertently,inadvertently +indcates,indicates +indciate,indicate +inddex,index +indecate,indicate +indeces,indices +indecies,indices indefenite,indefinite indefinate,indefinite indefinately,indefinitely @@ -12984,24 +25334,67 @@ indefinetely,indefinitely indefinetly,indefinitely indefininte,indefinite indefinitelly,indefinitely +indefinitiley,indefinitely indefinitive,indefinite +indefinitively,indefinitely indefinitley,indefinitely indefinitly,indefinitely indefinity,indefinitely indefintiely,indefinitely +indefintly,indefinitely indeginous,indigenous +indempotent,idempotent +indendation,indentation +indended,intended,indented +indentaion,indentation +indentended,indented indentical,identical -indepdenent,independents +indentically,identically +indentifer,identifier +indentification,identification +indentified,identified +indentifier,identifier +indentifies,identifies +indentifing,identifying +indentify,identify +indentifying,identifying +indentit,identity +indentity,identity +indenx,index +indepandance,independence +indepdence,independence +indepdencente,independence +indepdendance,independence +indepdendant,independent +indepdendantly,independently +indepdendence,independence +indepdendency,independency +indepdendent,independent +indepdendently,independently +indepdendet,independent +indepdendetly,independently +indepdenence,independence +indepdenent,independents,independent +indepdenently,independently +indepdent,independent +indepdented,independent +indepdentedly,independently +indepdently,independently indepedantly,independently indepedence,independence +indepedent,independent indepednent,independents indepencence,independence +independ,independent independance,independence independant,independent independante,independents independantes,independents independantly,independently independece,independence +independed,independent +independedly,independently +independend,independent independendet,independent independendly,independently independenet,independents @@ -13016,13 +25409,26 @@ independet,independent independetly,independently independetn,independents independets,independents -independnet,independents +independly,independently +independnent,independent +independnet,independents,independent +independnt,independent +independntly,independently +independt,independent +independtly,independently +indepenendence,independence indepenent,independent +indepenently,independently +indepent,independent indepentend,independents indepentent,independent indepentently,independently indepentents,independents +indepently,independently +inderect,indirect inderictly,indirectly +inderts,inserts +indes,index indespensable,indispensable indespensible,indispensable indestrictible,indestructible @@ -13031,7 +25437,11 @@ indestructibe,indestructible indestructuble,indestructible indetifiable,identifiable indetification,identification +indexig,indexing +indexs,indexes,indices +indext,index,indent indiaan,indiana +indiactor,indicator indianaoplis,indianapolis indianapols,indianapolis indianas,indians @@ -13040,7 +25450,15 @@ indiania,indiana indianna,indiana indianopolis,indianapolis indianos,indians +indiate,indicate +indiated,indicated +indiates,indicates +indiating,indicating +indicaite,indicate indicaste,indicates +indicat,indicate +indicateds,indicated,indicates +indicatee,indicates,indicated indicaters,indicates indicateurs,indicates indicatie,indicative @@ -13048,14 +25466,26 @@ indicatiors,indicators indicativo,indication indicato,indication indicatore,indicate -indicats,indicators +indicats,indicators,indicates,indicate +indicees,indices indicence,incidence indicentally,incidentally indicents,incidents +indiciate,indicate +indiciated,indicated +indiciates,indicates +indiciating,indicating +indicies,indices indicitave,indicative indicitive,indicative +indicte,indicate indictement,indictment +indictes,indicates +indictor,indicator indictrinated,indoctrinated +indide,inside +indien,indian,endian +indiens,indians,endians indifferance,indifference indifferant,indifferent indifferente,indifference @@ -13076,6 +25506,8 @@ indimidation,intimidation indipendence,independence indipendent,independent indipendently,independently +indiquate,indicate +indiquates,indicates indireclty,indirectly indirectely,indirectly indirecty,indirectly @@ -13084,12 +25516,21 @@ indisious,insidious indispensible,indispensable indisputible,indisputable indisputibly,indisputably +indistiguishable,indistinguishable indistinguisable,indistinguishable indistinguishible,indistinguishable indistingusihable,indistinguishable indistinquishable,indistinguishable indistructible,indestructible indistuingishable,indistinguishable +indivdual,individual +indivdually,individually +indivdualy,individually +individaul,individual +individaully,individually +individauls,individuals +individauly,individually +individial,individual individiual,individual individuais,individuals individuales,individuals @@ -13099,15 +25540,22 @@ individualy,individually individuati,individuality individuel,individual individuella,individual +individuelly,individually individuels,individuals +individuely,individually individul,individual individus,individuals +indiviual,individual +indiviually,individually +indiviuals,individuals indiviudal,individuals indiviudally,individually +indivual,individual indivudual,individual indivuduality,individuality indivudually,individually indivuduals,individuals +indizies,indices indluge,indulge indocrtinated,indoctrinated indocrtination,indoctrination @@ -13135,6 +25583,7 @@ indroduction,introduction indroductory,introductory indugle,indulge indulgue,indulge +indure,endure industiral,industrial industiralized,industrialized industires,industries @@ -13153,20 +25602,43 @@ industrijske,industries industrualized,industrialized industructible,indestructible indutrial,industrial +indvidual,individual indviduals,individuals +indxes,indexes +inearisation,linearisation ineffecitve,ineffective ineffektive,ineffective inefficeint,inefficient +inefficency,inefficiency inefficent,inefficient +inefficently,inefficiently +inefficenty,inefficiently inefficiant,inefficient inefficienct,inefficient inefficienty,inefficiently +inefficieny,inefficiency,inefficiently ineffictive,ineffective +ineffient,inefficient +ineffiently,inefficiently ineffizient,inefficient +ineficient,inefficient +inegrate,integrate +inegrated,integrated +ineqality,inequality ineqaulity,inequality inequailty,inequality +inequalitiy,inequality inequallity,inequality +inerface,interface +inernal,internal +inerrupt,interrupt +inershia,inertia +inershial,inertial inersting,inserting +inertion,insertion +ines,lines +inestart,linestart +inetrrupts,interrupts inevatible,inevitable inevetable,inevitable inevetably,inevitably @@ -13186,6 +25658,8 @@ inevtiable,inevitable inevtiably,inevitably inexblicably,inexplicably inexeprienced,inexperience +inexistant,inexistent +inexpect,inexpected inexpectedly,unexpectedly inexpeirenced,inexperience inexpencive,inexpensive @@ -13203,8 +25677,10 @@ inexperiened,inexperienced inexperiente,inexperience inexperince,inexperience inexperineced,inexperience -inexpierence,inexperienced +inexpierence,inexperienced,inexperience inexpierenced,inexperienced +inexpirience,inexperience +inexpirienced,inexperienced inexplicabil,inexplicably inexplicablely,inexplicably inexplicabley,inexplicably @@ -13216,8 +25692,11 @@ infallable,infallible infallibale,infallible infallibe,infallible infallibile,infallible -infaltable,inflatable +infaltable,inflatable,infallible infalte,inflate +infalted,inflated +infaltes,inflates +infalting,inflating infantis,infants infantus,infants infarred,infrared @@ -13230,6 +25709,8 @@ infedility,infidelity infektious,infectious infenro,inferno infered,inferred +inferface,interface +infering,inferring inferioara,inferior inferioare,inferior inferioir,inferior @@ -13238,12 +25719,14 @@ inferiorty,inferiority inferiour,inferior inferir,inferior infermon,inferno +inferrable,inferable inferrence,inference infestaion,infestation infestating,infestation infestato,infestation infestaton,infestation infestions,infections +infex,index infideltiy,infidelity infidility,infidelity infilitrate,infiltrate @@ -13269,17 +25752,21 @@ infinet,infinite infinetely,infinitely infinie,infinite infiniment,infinite +infininte,infinite infinit,infinite infinitelly,infinitely infinitey,infinity infinitie,infinite infinitiy,infinity infinitley,infinitely -infinitly,infinity +infinitly,infinity,infinitely +infinte,infinite +infintesimal,infinitesimal infintie,infinite infintiely,infinitely infintiy,infinity infintrator,infiltrator +infinty,infinity inflamable,inflatable inflamation,inflammation inflatabale,inflatable @@ -13287,16 +25774,23 @@ inflatabe,inflatable inflateble,inflatable inflatible,inflatable inflatie,inflate +inflatoin,inflation infleunced,influenced +inflexable,inflexible inflitrate,infiltrate inflitrator,infiltrator influanced,influenced influances,influences influancing,influencing +influece,influence +influeced,influenced +influeces,influences +influecing,influencing influenceing,influencing influencial,influential influencian,influencing influencie,influences +influencin,influencing influening,influencing influens,influences influense,influences @@ -13311,6 +25805,7 @@ influenting,influencing influentual,influential influincing,influencing influneced,influenced +infoemation,information infograhic,infographic infograhpic,infographic infograpgic,infographic @@ -13318,28 +25813,54 @@ infograpic,infographic infogrpahic,infographic infogrpahics,infographic infomation,information +infomational,informational +infomed,informed +infomer,informer +infoms,informs +infor,info +inforamtion,information +inforation,information +inforational,informational +inforce,enforce +inforced,enforced inforgivable,unforgivable informable,informal informacion,information +informaion,information +informaiton,information informarla,informal informarle,informal informarlo,informal informas,informs +informatation,information +informatations,information informate,informative informatice,informative informatie,informative informatief,informative informatiei,informative informatike,informative +informatikon,information +informatin,information,informing +informatins,information +informatio,information +informatiom,information +informations,information informativo,information +informatoin,information +informatoins,information +informaton,information informella,informal informerad,informed +informfation,information informis,informs informitive,informative informtion,information infornt,infront +inforrmation,information infrantryman,infantryman infraread,infrared +infrasctructure,infrastructure infrastracture,infrastructure infrastructre,infrastructure infrastructuur,infrastructure @@ -13347,7 +25868,17 @@ infrastrucure,infrastructure infrastrucutre,infrastructure infrastrukture,infrastructure infrastrutture,infrastructure +infrastruture,infrastructure infrasturcture,infrastructure +infreqency,infrequency +infreqentcy,infrequency +infreqeuncy,infrequency +infreqeuntcy,infrequency +infrequancies,infrequencies +infrequancy,infrequency +infrequantcies,infrequencies +infrequantcy,infrequency +infrequentcies,infrequencies infridgement,infringement infridging,infringing infrigement,infringement @@ -13357,12 +25888,16 @@ infringeing,infringing infromal,informal infromation,information infromative,informative +infromatoin,information infromed,informed infroms,informs +infrormation,information infrotn,infront +infrustructure,infrastructure infulenced,influenced infulences,influences infulential,influential +ingegral,integral ingenius,ingenious ingeniuty,ingenuity ingenuitiy,ingenuity @@ -13370,9 +25905,19 @@ ingerdients,ingredients ingestigator,investigator ingeunity,ingenuity ingition,ignition +ingnorar,ignore,ignorant +ingnore,ignore +ingnored,ignored +ingnores,ignores +ingnoring,ignoring ingocnito,incognito ingorance,ignorance ingorant,ignorant +ingore,ignore +ingored,ignored +ingores,ignores +ingoring,ignoring +ingration,integration ingrediant,ingredient ingrediants,ingredients ingrediens,ingredients @@ -13391,33 +25936,81 @@ inheirtance,inheritance inheirted,inherited inherantly,inherently inheratance,inheritance +inheret,inherit inheretance,inheritance +inherets,inherits inheriet,inherit inherint,inherit inherintly,inherently -inheritage,heritage +inheritablility,inheritability +inheritage,heritage,inheritance inheritence,inheritance +inherith,inherit +inherithed,inherited +inherithing,inheriting +inheriths,inherits +inheritted,inherited inhernetly,inherently +inherrit,inherit +inherritance,inheritance +inherrited,inherited +inherriting,inheriting +inherrits,inherits inhertiance,inheritance inhertied,inherited +inhertig,inheriting,inherited +inherting,inheriting +inhomogenous,inhomogeneous inhumaan,inhuman inhumain,inhuman +inialized,initialized +iniate,initiate inidans,indians +inidicates,indicates +inidvidual,individual +inifinite,infinite +inifinte,infinite inifnite,infinite inifnitely,infinitely inifnity,infinity inintelligent,unintelligent ininterested,uninterested ininteresting,uninteresting +inintialization,initialization inisghts,insights +initail,initial +initailisation,initialisation +initailise,initialise +initailised,initialised +initailiser,initialiser +initailisers,initialisers +initailises,initialises +initailising,initialising +initailization,initialization +initailize,initialize +initailized,initialized +initailizer,initializer +initailizers,initializers +initailizes,initializes +initailizing,initializing initailly,initially initails,initials +initailsation,initialisation +initailse,initialise +initailsed,initialised +initailsiation,initialisation +initaily,initially +initailzation,initialization +initailze,initialize +initailzed,initialized +initailziation,initialization initaite,initiate initaition,initiation initaitives,initiatives inital,initial initaled,initialed initalese,initialese +initalialization,initialization initaling,initialing initalisation,initialisation initalisations,initialisations @@ -13443,11 +26036,52 @@ initalling,initialling initally,initially initalness,initialness initals,initials +initate,initiate,imitate +initated,initiated,imitated initation,initiation +initators,initiators initiaitive,initiative initiaitve,initiatives -initiales,initials +initiales,initials,initialise,initializes,initialise,initialises +initialialize,initialize +initialiase,initialise,initialise +initialiation,initialization +initialiazation,initialization +initialiaze,initialize +initialiazed,initialized +initialied,initialized +initialilzing,initializing +initialisiert,initialised,initialised +initialiting,initializing +initialitze,initialize +initialitzing,initializing +initializaing,initializing +initializaiton,initialization +initializatin,initialization +initializationg,initialization +initializeing,initializing +initializiation,initialization +initializong,initializing +initializs,initialize,initializes +initialse,initialise,initialise +initialsed,initialised,initialised +initialses,initialises,initialises +initialsing,initialising initialy,initially +initialyl,initially +initialyse,initialise,initialise +initialysed,initialised,initialised +initialyses,initialises,initialises +initialysing,initialising,initialising +initialyze,initialize +initialyzed,initialized +initialyzes,initializes +initialyzing,initializing +initialzation,initialization +initialze,initialize +initialzed,initialized +initialzes,initializes +initialzing,initializing initiatie,initiatives initiaties,initiatives initiatin,initiation @@ -13455,15 +26089,54 @@ initiativs,initiatives initiatve,initiate initiatves,initiatives initiavite,initiatives +initiialise,initialise +initiialize,initialize +initilialised,initialised +initilialized,initialized +initiliase,initialise,initialise +initiliased,initialised,initialised +initiliases,initialises,initialises +initiliasing,initialising,initialising +initiliaze,initialize +initiliazed,initialized +initiliazes,initializes +initiliazing,initializing +initilisation,initialisation,initialisation +initilisations,initialisations,initialisations +initilise,initialise,initialise +initilised,initialised,initialised +initilises,initialises,initialises +initilising,initialising,initialising +initilization,initialization +initilizations,initializations +initilize,initialize +initilized,initialized +initilizes,initializes +initilizing,initializing initisl,initials inititaive,initiatives +inititate,initiate +inititator,initiator inititiave,initiatives inititiaves,initiatives +initliasation,initialisation +initliase,initialise +initliased,initialised +initliaser,initialiser +initliazation,initialization +initliaze,initialize +initliazed,initialized +initliazer,initializer initmacy,intimacy initmate,intimate initmately,intimately initmidate,intimidate +inituialization,initialization inituition,initiation +inivisible,invisible +inizialize,initialize +inizialized,initialized +inizializes,initializes injustaces,injustices injusticas,injustices injustics,injustices @@ -13471,22 +26144,57 @@ injustie,injustices inkompatible,incompatible inkompetence,incompetence inkonsistent,inconsistent +inlalid,invalid inlcine,incline +inlclude,include +inlcluded,included +inlcludes,includes +inlcluding,including +inlcludion,inclusion +inlclusive,inclusive +inlcude,include inlcuded,included inlcudes,includes inlcuding,including +inlcusion,inclusion +inlcusive,inclusive inlightening,enlightening +inlin,inline +inlude,include +inluded,included +inludes,includes +inluding,including +inludung,including +inluence,influence +inlusive,inclusive +inmediate,immediate +inmediatelly,immediately +inmediately,immediately +inmediatily,immediately +inmediatly,immediately +inmense,immense inmigrant,immigrant inmigrants,immigrants +inmmediately,immediately +inmplementation,implementation +innactive,inactive +innacurate,inaccurate +innacurately,inaccurately +innappropriate,inappropriate +inneffectual,ineffectual innersection,intersection innerstellar,interstellar +innitialize,initialize,initializes innoavtion,innovations innocens,innocents innocenters,innocents innocentes,innocents innocentius,innocents +innocous,innocuous +innoculate,inoculate innoculated,inoculated innocuos,innocuous +innosense,innocence innotation,innovation innoucous,innocuous innovacion,innovation @@ -13500,8 +26208,16 @@ innvoate,innovate innvoation,innovation inocence,innocence inofficial,unofficial +inofrmation,information +inoquous,innocuous inot,into +inout,input +inouts,inputs inovker,invoker +inpact,impact +inpacted,impacted +inpacting,impacting +inpacts,impacts inpeach,impeach inpection,inception inpending,impending @@ -13510,14 +26226,29 @@ inperfections,imperfections inpersonating,impersonating inplementation,implementation inplementations,implementations +inplemented,implemented inplementing,implementing inplications,implications +inplicit,implicit +inplicitly,implicitly inpolite,impolite +inport,import +inportant,important +inposible,impossible inpossibility,impossibility +inpossible,impossible inpoverished,impoverished inpredictable,unpredictable inprisonment,imprisonment inproductive,unproductive +inproove,improve +inprooved,improved +inprooves,improves +inprooving,improving +inproovment,improvement +inproovments,improvements +inproper,improper +inproperly,improperly inprovements,improvements inproving,improving inpsect,inspect @@ -13527,6 +26258,12 @@ inpsiration,inspiration inpsire,inspire inpsired,inspired inpsiring,inspiring +inpterpreter,interpreter +inpu,input +inpust,input,inputs +inputed,inputted +inputsream,inputstream +inpuut,input inquier,inquire inquirey,inquiry inquirie,inquire @@ -13549,14 +26286,24 @@ inquizition,inquisition inquizitor,inquisitor inquriy,inquiry inqusitior,inquisitor +inreractive,interactive +inrerface,interface inresponsible,irresponsible inresponsive,unresponsive inrested,inserted inresting,inserting +inro,into +insallation,installation +insalled,installed +insance,instance,insane insanelly,insanely insaney,insanely insanley,insanely inscets,insects +inscpeting,inspecting +insctuction,instruction +insctuctions,instructions +insde,inside insectes,insects insectiverous,insectivorous insectos,insects @@ -13564,7 +26311,12 @@ insecurites,insecurities insecuritites,insecurities insensative,insensitive insensetive,insensitive +insensistive,insensitive +insensistively,insensitively +insensitivy,insensitivity insensitve,insensitive +insenstive,insensitive +insenstively,insensitively insentitive,insensitive insentivised,insensitive insentivises,insensitive @@ -13572,10 +26324,27 @@ insepct,inspect insepction,inspection insepctions,inspections insepctor,inspector +insepect,inspect +insepected,inspected +insepection,inspection +insepects,inspects +insependent,independent inseperable,inseparable +insepsion,inception +insering,inserting +insersect,intersect +insersected,intersected +insersecting,intersecting +insersects,intersects insertas,inserts insertes,inserts +insertin,inserting +insertino,inserting insertos,inserts +insesitive,insensitive +insetad,instead +inseted,inserted +insided,inside insidios,insidious insidiuos,insidious insiginficant,insignificant @@ -13585,7 +26354,10 @@ insignificat,insignificant insignificent,insignificant insignificunt,insignificant insignifigant,insignificant +insigt,insight +insigth,insight insigths,insights +insigts,insights insinuationg,insinuating insipration,inspiration insiprational,inspirational @@ -13600,6 +26372,7 @@ insistenze,insistence insistes,insists insistince,insistence insistis,insists +insititute,institute insitution,institution insitutions,institutions insluated,insulated @@ -13607,6 +26380,7 @@ insluts,insults insmonia,insomnia insomina,insomnia insonmia,insomnia +insonsistency,inconsistency insparation,inspiration inspeccion,inspection inspeciton,inspections @@ -13627,22 +26401,41 @@ inspiraton,inspiration inspirerad,inspired inspireras,inspires inspiritional,inspirational +inspite,inspire inspriation,inspiration inspriational,inspirational inspried,inspired inspries,inspires insrugency,insurgency +instabce,instance instabiliy,instability instabillity,instability instabilt,instability instabilty,instability +instace,instance +instaces,instances +instaciate,instantiate +instad,instead instade,instead +instaead,instead +instaed,instead instalaltion,installations instalation,installation +instalations,installations +instaled,installed instalement,installment +instaling,installing +installaion,installation +installaiton,installation +installaitons,installations +installataion,installation +installataions,installations +installatation,installation installatin,installations +installationa,installation installatons,installations installatron,installation +installe,installer,installed,install installeer,installer installeert,installer installemnt,installment @@ -13652,9 +26445,23 @@ installesd,installs installion,installing installling,installing installmant,installment +installtion,installation installus,installs +instancd,instance instanciate,instantiate +instanciated,instantiated +instanciates,instantiates +instanciating,instantiating +instanciation,instantiation +instanciations,instantiations +instane,instance +instanes,instances instanse,instances +instanseation,instantiation +instansiate,instantiate +instansiated,instantiated +instansiates,instantiates +instansiation,instantiation instantaenous,instantaneous instantaneos,instantaneous instantaneoulsy,instantaneous @@ -13662,14 +26469,31 @@ instantaneu,instantaneous instantaneus,instantaneous instantanious,instantaneous instantanous,instantaneous +instantate,instantiate +instantating,instantiating +instantation,instantiation +instantations,instantiations instanteneous,instantaneous instantenious,instantaneous +instantiaties,instantiates instanty,instantly +instanze,instance instatance,instance +instatiate,instantiate instatutionalized,institutionalized +insteance,instance +insted,instead +insteead,instead instelling,installing +inster,insert +insterad,instead instered,inserted instering,inserting +insterrupts,interrupts +instersction,intersection +instert,insert +insterted,inserted +instertion,insertion insticnt,instinct insticnts,instincts instincitvely,instinctively @@ -13699,15 +26523,41 @@ instituto,institution instituttet,institute institutue,instituted institutuion,institution +instnace,instance +instnaces,instances +instnance,instance +instnances,instances +instnat,instant +instnatiated,instantiated +instnatiation,instantiation +instnatiations,instantiations +instnce,instance +instnces,instances +instnsiated,instantiated +instnsiation,instantiation +instnsiations,instantiations +instnt,instant +instntly,instantly +instrace,instance +instralled,installed instrament,instrument instramental,instrumental instraments,instruments -instrcutions,instruction +instrction,instruction +instrcut,instruct +instrcutino,instruction +instrcutinos,instructions +instrcution,instruction +instrcutions,instruction,instructions instrcutor,instructors +instrcuts,instructs +instread,instead +instrinsic,intrinsic instruccion,instruction +instruccions,instructions instrucion,instruction instruciton,instruction -instrucitons,instruction +instrucitons,instruction,instructions instructer,instructor instructers,instructors instructie,instructed @@ -13720,9 +26570,15 @@ instructores,instructors instruktion,instruction instruktor,instructor instrumenal,instrumental +instrumenet,instrument +instrumenetation,instrumentation +instrumenetd,instrumented +instrumeneted,instrumented +instrumentaion,instrumentation instrumentos,instruments instrumentul,instrumental instrumetal,instrumental +instsallation,installation instuction,instruction instuments,instruments insturcted,instructed @@ -13745,14 +26601,17 @@ instututionalized,institutionalized insualted,insulated insubstantiated,unsubstantiated insuccessful,unsuccessful +insue,ensue,insure insufficent,insufficient insufficiant,insufficient +insuffiency,insufficiency insuffucient,insufficient insuinating,insinuating insultas,insults insultes,insults insultos,insults insuniating,insinuating +insurasnce,insurance insurence,insurance insurgance,insurgency insurgancy,insurgency @@ -13760,16 +26619,34 @@ insurgencey,insurgency insurgeny,insurgency insuspecting,unsuspecting insustainable,unsustainable +intaces,instance +intack,intact +intall,install intamicy,intimacy intamite,intimate +intance,instance,intense +intances,instances intangable,intangible intangeble,intangible intangiable,intangible intangibil,intangible intangibile,intangible intanjible,intangible +intantiate,instantiate +intantiating,instantiating intaxication,intoxication +inteaction,interaction +intead,instead +inted,inetd,intend +inteded,intended +intedned,intended +inteface,interface inteferring,interfering +integarte,integrate +integarted,integrated +integartes,integrates +integeral,integral +integere,integer integirty,integrity integraal,integral integracion,integration @@ -13780,14 +26657,25 @@ integrarlo,integral integratie,integrated integrato,integration integratron,integration +integreated,integrated integreres,interferes integrering,interfering integreted,integrated +integrety,integrity +integrey,integrity intelectual,intellectual +intelegence,intelligence +intelegent,intelligent +intelegently,intelligently intelelctual,intellectuals intelelctuals,intellectuals +inteligability,intelligibility +inteligable,intelligible +inteligance,intelligence +inteligantly,intelligently inteligence,intelligence inteligent,intelligent +intelisense,intellisense intellectals,intellectuals intellectaul,intellectuals intellectualis,intellectuals @@ -13804,6 +26692,7 @@ intellecutally,intellectually intellecutals,intellectuals intellegent,intelligent intellegently,intelligently +intelligable,intelligible intelligance,intelligence intelligant,intelligent intelligenly,intelligently @@ -13811,27 +26700,59 @@ intelligente,intelligence intelligenty,intelligently intelligient,intelligent intelluctuals,intellectuals +intemediary,intermediary intenational,international intencional,intentional intendes,intends +intendet,intended intendos,intends +inteneded,intended intenisty,intensity intenseley,intensely +intension,intention +intensional,intentional +intensionally,intentionally +intensionaly,intentionally +intensitive,insensitive,intensive intensitiy,intensity intensley,intensely intenst,intents intentas,intents -intented,intended +intentation,indentation +intented,intended,indented +intentended,intended +intentially,intentionally +intentialy,intentionally intentinal,intentional intentines,intestines +intentionaly,intentionally intentionly,intentional intentionnal,intentional +intepolate,interpolate +intepolated,interpolated +intepolates,interpolates +intepret,interpret +intepretable,interpretable intepretation,interpretation -intepretator,interpretor +intepretations,interpretations +intepretator,interpretor,interpreter +intepretators,interpreters +intepreted,interpreted +intepreter,interpreter +intepreters,interpreters +intepretes,interprets +intepreting,interpreting +intepretor,interpreter +intepretors,interpreters +inteprets,interprets interaccion,interaction -interace,interacted +interace,interacted,interface +interaces,interfaces interacive,interactive +interacively,interactively interacs,interacts +interacsion,interaction +interacsions,interactions interacte,interactive interactes,interacts interactice,interactive @@ -13839,24 +26760,53 @@ interactie,interactive interacties,interacts interactifs,interacts interactins,interacts +interactionn,interaction +interactionns,interactions interactios,interacts +interactiv,interactive +interactivly,interactively interactivo,interaction interactons,interacts +interactuable,interactive interactue,interacted +interafce,interface +interakt,interact interaktion,interaction -interaktive,interactive +interaktions,interactions +interaktive,interactive,interactively +interaktively,interactively +interaktivly,interactively +interal,internal,interval,integral +interally,internally +interals,internals,intervals,integrals +interaly,internally +interanl,internal +interanlly,internally interasted,interacted interasting,interacting +interate,iterate +interated,iterated,interacted interatellar,interstellar +interates,iterates,interacts +interating,iterating,interacting +interation,iteration,interaction interational,international -interbread,interbreed -intercation,integration +interations,iterations,interactions +interative,interactive +interatively,interactively +interator,iterator +interators,iterators +interbread,interbreed,interbred +intercahnge,interchange +intercahnged,interchanged +intercation,integration,interaction intercection,interception intercepcion,interception intercepticons,interceptions interceptin,interception intercepto,interception interceptons,interceptions +interchage,interchange interchangable,interchangeable interchangabley,interchangeably interchangably,interchangeably @@ -13867,6 +26817,7 @@ interchangebale,interchangeable interchangeble,interchangeable interchangebly,interchangeably intercoarse,intercourse +intercollegate,intercollegiate intercontinential,intercontinental intercontinetal,intercontinental intercorse,intercourse @@ -13875,16 +26826,28 @@ intercouse,intercourse intereaction,intersection intereactions,intersections intereacts,interfaces +interecptor,interceptor interect,interacted interected,interacted interecting,interacting interection,interaction interections,interactions -intered,interred +intered,interred,interned +intereested,interested +intereference,interference +intereferences,interferences interefers,interferes interelated,interrelated +interelaved,interleaved interent,internet interents,internets +interepret,interpret +interepretation,interpretation +interepretations,interpretations +interepreted,interpreted +interepreting,interpreting +intereprets,interprets +interept,intercept interersted,interpreted interersting,interpreting interesant,interest @@ -13892,18 +26855,40 @@ interesat,interest interesction,intersection interesctions,intersections interese,interested +interesect,intersect +interesected,intersected +interesecting,intersecting +interesection,intersection +interesections,intersections +interesects,intersects +intereset,interest +intereseted,interested +intereseting,interesting interesing,interesting +interespersed,interspersed interesring,interfering -interesst,interests +interesseted,interested +interesst,interests,interest interessted,interested +interessting,interesting interestes,interests interestigly,interestingly interestinly,interestingly interet,interest +intereview,interview interewbs,interwebs interfacce,interfaces +interfal,interval +interfals,intervals interfase,interfaces +interfave,interface +interfaves,interfaces +interfcae,interface +interfcaes,interfaces interfce,interface +interfear,interfere +interfearence,interference +interfearnce,interference interfears,interferes interfeer,interfere interfeers,interferes @@ -13917,7 +26902,7 @@ interferisce,interferes interferisse,interferes interfernce,interference interferre,interfere -interferred,interfere +interferred,interfere,interfered interferres,interferes interferring,interfering interfers,interferes @@ -13925,29 +26910,46 @@ intergal,integral intergate,integrate intergated,integrated intergation,integration +interger,integer +intergerated,integrated +intergers,integers intergity,integrity intergrated,integrated +intergrating,integrating intergration,integration interioara,interior interioare,interior interiour,interior +interit,inherit +interitance,inheritance +interited,inherited +interiting,inheriting +interits,inherits interlectual,intellectual interlectually,intellectually interlectuals,intellectuals -interm,interim +interliveing,interleaving +interlly,internally +interm,interim,intern intermedate,intermediate intermediare,intermediate intermedie,intermediate intermediete,intermediate intermedite,intermediate +intermeidate,intermediate intermettent,intermittent intermideate,intermediate intermidiate,intermediate intermitent,intermittent +intermittant,intermittent intermittient,intermittent intermittment,intermittent +intermperance,intemperance internacional,international +internall,internal,internally +internaly,internally internatinal,international +internatioanl,international internation,international internationaal,international internationaly,internationally @@ -13956,7 +26958,9 @@ internationnal,international internationnally,internationally internations,interactions internediate,intermediate +internel,internal internelized,internalized +internels,internals internest,internets internetbs,internets interneters,internets @@ -13969,10 +26973,15 @@ internetors,internets internettes,internets internetts,internets internetus,internets +internface,interface internilized,internalized internt,internet internts,interns internus,interns +interogators,interrogators +interopeable,interoperable +interoprability,interoperability +interperated,interpreted interpersonel,interpersonal interpersonnal,interpersonal interpert,interpret @@ -13983,11 +26992,31 @@ interperter,interpreter interperters,interpreter interperting,interpreting interpet,interpret +interpetation,interpretation +interpeted,interpreted +interpeter,interpreter +interpeters,interpreters +interpeting,interpreting +interpets,interprets +interploate,interpolate +interploated,interpolated +interploates,interpolates +interploatin,interpolating +interploation,interpolation +interpolaed,interpolated +interpolaion,interpolation +interpolaiton,interpolation +interpolar,interpolator +interpolayed,interpolated +interporated,interpolated,interpreted interpratation,interpretation interpratations,interpretations interprate,interpret +interprated,interpreted interprating,interpreting +interpreation,interpretation interprered,interpreter +interprerter,interpreter interpresonal,interpersonal interpretacion,interpretation interpretaciones,interpretations @@ -13999,70 +27028,116 @@ interpretarem,interpreter interpretares,interpreter interpretarse,interpreter interpretarte,interpreter +interpretated,interpreted interpretatin,interpretations interpretating,interpretation interpretationen,interpretations interpretato,interpretation +interprete,interpret interpreteer,interpreter interpreteert,interpreter +interpretes,interprets +interpretet,interpreted interpretier,interpreter -interpretion,interpreting +interpretion,interpreting,interpretation +interpretions,interpretations +interprett,interpret +interpretted,interpreted interpretter,interpreter +interpretting,interpreting interpritation,interpretation interpritations,interpretations interpriting,interpreting interprut,interrupt interraccial,interracial +interract,interact interractial,interracial +interracting,interacting +interractive,interactive +interracts,interacts interragation,interrogation interratial,interracial interregation,interrogation interresing,interfering +interrest,interest +interrested,interested +interresting,interesting +interrface,interface interrigation,interrogation interrim,interim +interript,interrupt interro,interior interrogacion,interrogation interrogatin,interrogation interrogativo,interrogation interrogato,interrogation +interrput,interrupt interrputed,interrupted +interrrupt,interrupt +interrrupted,interrupted +interrrupting,interrupting +interrrupts,interrupts +interrtups,interrupts interrugum,interregnum +interrum,interim interrumping,interrupting +interrup,interrupt interruped,interrupted interruping,interrupting interrups,interrupts +interruptable,interruptible interrupteds,interrupts interruptes,interrupts interruptis,interrupts -interruptors,interrupts +interruptors,interrupts,interrupters +interruptted,interrupted +interrut,interrupt +interrutps,interrupts +interscetion,intersection interseccion,intersection interseciton,intersections +intersecrion,intersection intersectionals,intersections intersecton,intersection +intersectons,intersections interseption,interception +intersepts,intercepts,intersteps intersetllar,interstellar +intersparsed,interspersed +interst,interest interstae,interstate interstallar,interstellar interstaller,interstellar interste,interstate +intersted,interested interstela,interstellar interstelar,interstellar interstellaire,interstellar intersteller,interstellar interstellor,interstellar +intersting,interesting +intersts,interests intertained,intertwined intertaining,entertaining intertainment,entertainment +intertia,inertia +intertial,inertial intertvined,intertwined intertwinded,intertwined intertwinned,intertwined intertwyned,intertwined interupt,interrupt +interupted,interrupted +interupting,interrupting +interupts,interrupts +interuupt,interrupt +intervall,interval intervalles,intervals intervalls,intervals intervalos,intervals intervation,integration interveen,intervene +interveening,intervening interveign,intervening interveing,intervening interveiwed,interviewed @@ -14097,6 +27172,7 @@ interviwer,interviewer interwebbs,interwebs interwebers,interwebs interwiever,interviewer +intesity,intensity intesnely,intensely intesnity,intensity intestents,intestines @@ -14105,13 +27181,62 @@ intestinces,intestines intestinos,intestines intestins,intestines intestions,intestines +inteval,interval +intevals,intervals intevene,intervene +intgers,integers +intiailise,initialise +intiailised,initialised +intiailises,initialises +intiailize,initialize +intiailized,initialized +intiailizes,initializes +intiailizing,initializing intial,initial +intiale,initial +intialisation,initialisation +intialise,initialise +intialised,initialised +intialiser,initialiser +intialisers,initialisers +intialises,initialises +intialising,initialising +intialistion,initialisation +intialization,initialization +intializaze,initialize +intialize,initialize +intialized,initialized +intializer,initializer +intializers,initializers +intializes,initializes +intializing,initializing +intializtion,initialization +intialled,initialled +intiallisation,initialisation +intiallisations,initialisations +intiallised,initialised +intiallization,initialization +intiallizations,initializations +intiallized,initialized +intiallly,initially intially,initially +intials,initials +intialse,initialise +intialsed,initialised +intialsing,initialising +intialte,initialise +intialy,initially +intialze,initialize +intialzed,initialized +intialzing,initializing +inticement,enticement inticracies,intricacies inticrate,intricate intidimate,intimidate intidimation,intimidation +intiial,initial +intiialise,initialise +intiialize,initialize intiials,initials intillectual,intellectual intillectually,intellectually @@ -14143,8 +27268,16 @@ intimitate,intimidate intimitated,intimidated intimitating,intimidating intimitation,intimidation +intimite,intimate intimitely,intimately +intinite,infinite intircate,intricate +intitial,initial +intitialization,initialization +intitialize,initialize +intitialized,initialized +intitials,initials +intity,entity intiution,intuition intiutive,intuitive intiutively,intuitively @@ -14169,6 +27302,7 @@ intorductory,introductory intorvert,introvert intorverted,introverted intorverts,introverts +intot,into intoxicacion,intoxication intoxicatin,intoxication intoxicaton,intoxication @@ -14176,16 +27310,33 @@ intoxicted,intoxicated intoxinated,intoxicated intoxination,intoxication intoxocated,intoxicated +intpreter,interpreter +intput,input +intputs,inputs +intquire,inquire,inquire +intquired,inquired,inquired +intquires,inquires,inquires +intquiries,inquiries,inquiries +intquiry,inquiry,inquiry intracacies,intricacies intracicies,intricacies intracite,intricate intraspection,introspection +intraversion,introversion +intravert,introvert intraverted,introverted intraverts,introverts intrduced,introduced intrecacies,intricacies +intreeg,intrigue +intreeged,intrigued +intreeging,intriguing +intreegued,intrigued +intreeguing,intriguing +intreface,interface intregal,integral intregity,integrity +intregral,integral intreguing,intriguing intrenets,internets intrensically,intrinsically @@ -14195,13 +27346,22 @@ intrepretations,interpretations intrepreted,interpreted intrepreter,interpreter intrepreting,interpreting +intrerrupt,interrupt intrerupt,interrupt intrerupted,interrupted -intrest,interest +intresst,interest +intressted,interested +intressting,interesting +intrest,interest,insert +intrested,interested +intresting,interesting intrewebs,interwebs intricaces,intricacies intricasies,intricacies intricicies,intricacies +intriduce,introduce +intriduced,introduced +intriduction,introduction intrige,intrigue intrigueing,intriguing intriguied,intrigue @@ -14216,6 +27376,7 @@ intrinsisch,intrinsic intriquing,intriguing intrisinc,intrinsic intrisincally,intrinsically +intrisincs,intrinsics intrisnic,intrinsic intristically,intrinsically intriuge,intrigue @@ -14238,8 +27399,12 @@ introdue,introduces introdued,introduced introduktion,introduction introdus,introduces -introduse,introduces -introdused,introduces +introduse,introduces,introduce +introdused,introduces,introduced +introduses,introduces +introdusing,introducing +introsepectable,introspectable +introsepection,introspection introspeccion,introspection introspectin,introspection introspectivo,introspection @@ -14256,6 +27421,12 @@ introvertie,introverted introvertis,introverts introvet,introvert introveted,introverted +intrrupt,interrupt +intrrupted,interrupted +intrrupting,interrupting +intrrupts,interrupts +intruction,instruction +intructions,instructions intruduced,introduced intruduces,introduces intruducing,introducing @@ -14266,8 +27437,13 @@ intruiged,intrigued intruiging,intriguing intrument,instrument intrumental,instrumental +intrumented,instrumented +intrumenting,instrumenting intruments,instruments intsrumental,instrumental +intstead,instead +intterrupt,interrupt +intuative,intuitive intuatively,intuitively intuitevely,intuitively intuitevly,intuitively @@ -14276,19 +27452,30 @@ intuitivley,intuitively intuitivly,intuitively intuitivno,intuition intuituvely,intuitively +inturpratasion,interpretation +inturpratation,interpretation +inturprett,interpret inturrupting,interrupting intutive,intuitive intutively,intuitively inudstry,industry -inumerable,enumerable +inumerable,enumerable,innumerable inusrgency,insurgency +inut,input inutition,intuition inutitive,intuitive inutitively,intuitively invaderas,invaders invaderats,invaders +invaid,invalid +invaild,invalid invaildate,invalidates +invailid,invalid invairably,invariably +invalaid,invalid +invald,invalid +invaldates,invalidates +invalde,invalid invaldiate,invalidates invaldiates,invalidates invalidade,invalidate @@ -14296,13 +27483,19 @@ invalidades,invalidates invalidante,invalidate invalidare,invalidate invalidas,invalidates +invalidatiopn,invalidation +invalide,invalid +invalidiate,invalidate invalubale,invaluable +invalud,invalid invalueble,invaluable invaraibly,invariably invariabil,invariably invariabley,invariably invariablly,invariably invaribaly,invariably +invarient,invariant +invarients,invariants invaulable,invaluable inveitable,inevitable inveitably,inevitably @@ -14315,13 +27508,21 @@ inventings,inventions inventiones,inventions inventios,inventions inventivos,inventions +inverded,inverted +inverion,inversion +inverions,inversions +invers,inverse,invert invertendo,inverted inverterad,inverted invertes,inverse invertibrates,invertebrates invertions,inventions +inverval,interval invervention,intervention +inveryed,inverted invesitgate,investigate +invesitgated,investigated +invesitgating,investigating invesitgation,investigation invesitgations,investigations invesitgative,investigative @@ -14366,10 +27567,14 @@ investmens,investments investmet,investments investogator,investigator investogators,investigators +inveting,inverting +inviation,invitation invicibility,invisibility invicinble,invincible invididual,individual invididually,individually +invidual,individual +invidually,individually invincable,invincible invinceble,invincible invincibe,invincible @@ -14379,22 +27584,39 @@ invincinble,invincible invinicble,invincible invinsible,invincible invinvible,invincible +invisble,invisible +invisblity,invisibility +invisiable,invisible invisibiity,invisibility +invisibile,invisible invisibiliy,invisibility invisibillity,invisibility invisibiltiy,invisibility invisibily,invisibility invisilibity,invisibility +invisivble,invisible invisivility,invisibility invitacion,invitation invitating,invitation invitato,invitation +invlaid,invalid +invlid,invalid +invlisible,invisible invlove,involve invloved,involved invloves,involves invloving,involving invlunerable,invulnerable +invocaition,invocation invoekr,invoker +invokable,invocable +invokation,invocation +invokations,invocations +invokee,invoked,invoke +invokve,invoke +invokved,invoked +invokves,invokes +invokving,invoking involantary,involuntary involentary,involuntary involintary,involuntary @@ -14423,27 +27645,40 @@ invulnurable,invulnerable invulverable,invulnerable invunlerable,invulnerable invurnerable,invulnerable +ioclt,ioctl +iomaped,iomapped +ionde,inode iornman,ironman +iound,round,wound +iplementation,implementation +ipmrovement,improvement +ipmrovements,improvements ipubrofen,ibuprofen +iput,input iranain,iranian iranains,iranians iranianos,iranians iranias,iranians iranina,iranian iraninas,iranians +ireelevant,irrelevant irelevent,irrelevant iresistable,irresistible iresistably,irresistibly iresistible,irresistible iresistibly,irresistibly iritable,irritable +iritate,irritate iritated,irritated +iritating,irritating irleand,ireland ironamn,ironman ironcially,ironically ironicaly,ironically ironicly,ironically irracional,irrational +irradate,irradiate +irradation,irradiation irrationably,irrationally irrationallity,irrationally irrationallly,irrationally @@ -14452,12 +27687,19 @@ irrationatly,irrationally irrationel,irrational irrationella,irrational irrationnal,irrational +irregularties,irregularities +irregulier,irregular +irregulierties,irregularities irrelavant,irrelevant irrelavent,irrelevant irrelevent,irrelevant irrelivant,irrelevant irrelivent,irrelevant +irrelvant,irrelevant irreplacable,irreplaceable +irreplacalbe,irreplaceable +irreproducable,irreproducible +irresepective,irrespective irresistable,irresistible irresistably,irresistibly irrespecitve,irrespective @@ -14471,6 +27713,7 @@ irresponsibile,irresponsible irrevelant,irrelevant irreverant,irrelevant irreverisble,irreversible +irreversable,irreversible irreversebly,irreversible irreversiable,irreversible irreversibel,irreversible @@ -14493,7 +27736,13 @@ isalmists,islamists isalnders,islanders isareli,israeli isarelis,israelis +isconnection,isconnected +iscrated,iscreated isdefinitely,indefinitely +iself,itself +iselfe,itself +iserting,inserting +isimilar,similar islamisist,islamist islamisists,islamists islamiskt,islamist @@ -14508,11 +27757,16 @@ islandes,islanders islmaic,islamic islmaists,islamists isloate,isolate +isloation,isolation ismalist,islamist +ismas,isthmus +isnpiron,inspiron isntallation,installation +isntallations,installations isntaller,installer isntalling,installing isntalls,installs +isntance,instance isntances,instances isntantly,instantly isntructed,instructed @@ -14520,6 +27774,8 @@ isntrument,instrument isntrumental,instrumental isntruments,instruments isolatie,isolate +isotrophically,isotropically +isplay,display israeliens,israelis israelies,israelis israelitas,israelis @@ -14530,23 +27786,85 @@ israleis,israelis isralies,israelis isreali,israeli isrealis,israelis +isssue,issue +isssued,issued +isssues,issues issueing,issuing +ist,is,it,its,sit,list +istalling,installing +istance,instance +istead,instead +istened,listened +istener,listener +isteners,listeners +istening,listening +ists,its,lists +isue,issue italains,italians italianas,italians italianess,italians italianos,italians italias,italians +iteartor,iterator +iteger,integer +itegral,integral +itegrals,integrals +iten,item +itens,items +itention,intention +itentional,intentional +itentionally,intentionally +itentionaly,intentionally +iterater,iterator +iteratered,iterated +iteratons,iterations +itereating,iterating +iterface,interface +iterfaces,interfaces +iterm,term,item,intern +iternations,iterations +iterpreter,interpreter +iterrupt,interrupt +itertation,iteration +iteself,itself +itesm,items +itialise,initialise +itialised,initialised +itialises,initialises +itialising,initialising +itialize,initialize +itialized,initialized +itializes,initializes +itializing,initializing +itnerest,interest +itnerface,interface +itnerfaces,interfaces +itnernal,internal +itnervals,intervals itnroduced,introduced +itsef,itself +itselfs,itself +itselt,itself +itselv,itself +itsems,items +itslef,itself +itslev,itself +itteration,iteration +itterations,iterations iunior,junior +ivocation,invocation +iwithout,without iwll,will iwth,with jackonsville,jacksonville jacksonvile,jacksonville jacksonvillle,jacksonville jagaurs,jaguars +jagid,jagged jaguards,jaguars jaguares,jaguars jaguras,jaguars +jagwar,jaguar jailborken,jailbroken jailbrake,jailbreak jailbrek,jailbreak @@ -14555,6 +27873,7 @@ jailbrocken,jailbroken jaimacan,jamaican jalibreak,jailbreak jalibroken,jailbroken +jalusey,jealousy,jalousie jamacain,jamaican jamacia,jamaica jamaicain,jamaican @@ -14566,23 +27885,40 @@ jamiaca,jamaica jamiacan,jamaican jamsine,jasmine janaury,january +januar,january januaray,january janurary,january januray,january +japaneese,japanese japanes,japanese +japanses,japanese jaques,jacques jasmien,jasmine jaugars,jaguars jaunary,january +javacript,javascript +javascipt,javascript +javasciript,javascript +javascritp,javascript +javascropt,javascript +javasript,javascript +javasrript,javascript +jave,java,have +javsscript,javascript jeapardy,jeopardy jefferry,jeffery jefferty,jeffery +jeffies,jiffies jeircho,jericho +jelous,jealous +jelousy,jealousy +jelusey,jealousy jennigns,jennings jennins,jennings jeopary,jeopardy jeoprady,jeopardy jepoardy,jeopardy +jepordize,jeopardize jeresys,jerseys jericoh,jericho jersualem,jerusalem @@ -14593,13 +27929,21 @@ jeruselam,jerusalem jeruslaem,jerusalem jewelrey,jewelry jewerly,jewelry +jewl,jew,jewel jewllery,jewellery +jitterr,jitter +jitterring,jittering joanthan,jonathan +jodpers,jodhpurs joepardy,jeopardy johanine,johannine +joineable,joinable +joinning,joining jonatahn,jonathan +jornal,journal jorunal,journal jospeh,joseph +jossle,jostle jouney,journey jounral,journal jounralism,journalism @@ -14632,6 +27976,8 @@ journolist,journalist journolists,journalists joysitck,joystick joystik,joystick +jpng,png,jpg,jpeg +jscipt,jscript jstu,just jsut,just jsutification,justifications @@ -14657,6 +28003,7 @@ juducial,judicial jugdement,judgement jugdemental,judgemental jugdements,judgements +juge,judge juggarnaut,juggernaut juggeranut,juggernaut juggernat,juggernaut @@ -14672,6 +28019,10 @@ jugglenaut,juggernaut juggurnaut,juggernaut jugnling,jungling juipter,jupiter +jumo,jump +jumoed,jumped +jumpimng,jumping +jumpt,jumped,jump junglig,jungling junglign,jungling junlging,jungling @@ -14688,10 +28039,15 @@ juristiction,jurisdiction juristictions,jurisdictions jursidiction,jurisdiction jursidictions,jurisdictions +jus,just +juse,just,juice,jude,june jusitfication,justifications jusitfy,justify jusridiction,jurisdiction +justfied,justified justfiy,justify +justication,justification +justifed,justified justifiaction,justifications justifible,justifiable justificacion,justification @@ -14704,35 +28060,86 @@ justificstion,justifications justifiy,justify justifyable,justifiable justiifcation,justifications +justs,just juveline,juvenile juvenille,juvenile juvenilles,juvenile juvenlie,juvenile +juxt,just +juxtification,justification +juxtifications,justifications +juxtified,justified +juxtifies,justifies +juxtifying,justifying +kake,cake,take karakoe,karaoke karbohydrates,carbohydrates karoake,karaoke katastrophic,catastrophic katemine,ketamine +kazakstan,kazakhstan +keept,kept +kenel,kernel,kennel +kenels,kernels,kennels kenendy,kennedy +kenerl,kernel +kenerls,kernels keneysian,keynesian kenndey,kennedy kennedey,kennedy +kenrel,kernel +kenrels,kernels kentuckey,kentucky kentucy,kentucky kenyesian,keynesian +kepping,keeping +kepps,keeps +kerenl,kernel +kerenls,kernels +kernal,kernel +kernals,kernels +kernerl,kernel +kernerls,kernels +ket,kept ketmaine,ketamine +keword,keyword +kewords,keywords +kewword,keyword +kewwords,keywords keybaord,keyboard keybaords,keyboards +keyboaard,keyboard +keyboaards,keyboards keyboad,keyboard +keyboads,keyboards keyboars,keyboards +keybooard,keyboard +keybooards,keyboards keyborad,keyboard +keyborads,keyboards +keybord,keyboard +keybords,keyboards +keybroad,keyboard +keybroads,keyboards keychan,keychain keychian,keychain keyensian,keynesian keyesnian,keynesian +keyevente,keyevent keynode,keynote keynseian,keynesian +keyords,keywords +keyoutch,keytouch +keyowrd,keyword keysenian,keynesian +keystokes,keystrokes +keyward,keyword +keywoards,keywords +keywork,keyword +keyworkd,keyword +keyworkds,keywords +keywors,keywords +keywprd,keyword kickstarer,kickstarter kickstartr,kickstarter kickstater,kickstarter @@ -14766,15 +28173,22 @@ kitches,kitchens kitites,kitties kittiens,kitties klenex,kleenex +klick,click +klicked,clicked +klicks,clicks kncokback,knockback knietic,kinetic knigths,knights +knive,knife +kno,know knockbak,knockback knolwedgable,knowledgable knoweldgable,knowledgable knoweldge,knowledge knoweldgeable,knowledgeable knowladgable,knowledgable +knowlage,knowledge +knowlageable,knowledgeable knowldegable,knowledgable knowldgeable,knowledgable knowleagable,knowledgable @@ -14792,12 +28206,17 @@ knowlegdable,knowledgable knowlegde,knowledge knowlegdeable,knowledgeable knowlege,knowledge +knowlegeabel,knowledgeable knowlegeable,knowledgeable knuckel,knuckle knuckels,knuckles knwo,know +knwoing,knowing +knwoingly,knowingly knwoledgable,knowledgable +knwon,known knwos,knows +kocalized,localized kollaboration,collaboration kolonization,colonization kombinations,combinations @@ -14819,9 +28238,13 @@ konsultation,consultation kontamination,contamination konversation,conversation konw,know +konwn,known konws,knows +koordinate,coordinate +koordinates,coordinates koordination,coordination koreanos,koreans +kown,known krankenstein,frankenstein kroeans,koreans krpytonite,kryptonite @@ -14836,6 +28259,19 @@ kryptonyte,kryptonite krypyonite,kryptonite krytponite,kryptonite ktichen,kitchen +kubenates,kubernetes +kubenernetes,kubernetes +kubenertes,kubernetes +kubenetes,kubernetes +kubenretes,kubernetes +kuberenetes,kubernetes +kuberentes,kubernetes +kuberetes,kubernetes +kubermetes,kubernetes +kubernates,kubernetes +kubernests,kubernetes +kubernete,kubernetes +kuberntes,kubernetes kubirck,kubrick kunckle,knuckle kunckles,knuckles @@ -14843,12 +28279,20 @@ kurbick,kubrick kurdisch,kurdish kuridsh,kurdish kwno,know +kyrillic,cyrillic kyrptonite,kryptonite labarotory,laboratory -labatory,lavatory +labatory,lavatory,laboratory +labed,labeled +labeld,labeled labenese,lebanese +labirinth,labyrinth labirynth,labyrinth -labled,labeled +lable,label +labled,labeled,labeled +lablels,labels +lables,labels +labling,labeling,labeling laboratoy,laboratory laboratroy,laboratory laboraty,laboratory @@ -14856,6 +28300,7 @@ laborerers,laborers laboreres,laborers laboritory,laboratory laborotory,laboratory +labouriously,laboriously labratory,laboratory labriynth,labyrinth labryinth,labyrinth @@ -14865,6 +28310,11 @@ lacklaster,lackluster lacklusture,lacklustre laguage,language laguages,languages +laguague,language +laguagues,languages +laiter,later +lanaguage,language +lanauge,language landacapes,landscapes landingers,landings landins,landings @@ -14873,21 +28323,67 @@ landscaps,landscapes landscspe,landscapes landshapes,landscapes landspaces,landscapes +langage,language +langauage,language langauge,language langauges,languages +langeuage,language +langeuagesection,languagesection +languace,language +languaces,languages +languae,language +languaes,languages languague,language +languahe,language +languahes,languages +languaje,language +languajes,languages +langual,lingual +languale,language +languales,languages +langualge,language +langualges,languages +languange,language +languanges,languages +languaqe,language +languaqes,languages +languate,language +languates,languages +languauge,language +languauges,languages +languege,language +langueges,languages +langugae,language +langugaes,languages +langugage,language +langugages,languages +languge,language +languges,languages +langugue,language +langugues,languages lannasters,lannisters lannesters,lannisters lannistars,lannisters lannsiters,lannisters lantren,lantern +lanuage,language lanucher,launcher lanuchers,launchers lanuches,launches +lanugage,language lanugages,languages +laod,load +laoded,loaded +laoding,loading laodouts,loadouts +laods,loads +laotion,laotian +laout,layout laready,already laregly,largely +larg,large +larget,larger,largest,target +largets,largest,targets largley,largely largst,largest larington,arlington @@ -14897,13 +28393,28 @@ lasagnea,lasagna lasagnia,lasagna lasanga,lasagna lasgana,lasagna +laso,also,lasso +lastes,latest +lastest,latest lastr,last lateration,alteration +lates,later,latest +latets,latest +lating,latin +latitide,latitude latitudie,latitude latitudine,latitude latitue,latitude +latitute,latitude latnern,lantern +latops,laptops +latset,latest lattitude,latitude +lauch,launch +lauched,launched +laucher,launcher +lauches,launches +lauching,launching laucnhed,launched laucnher,launcher laucnhers,launchers @@ -14912,22 +28423,58 @@ laucnhing,launching laughablely,laughably laughabley,laughably laughablly,laughably +lauguage,language launchered,launched launchign,launching +launchs,launch,launches +launck,launch laundrey,laundry launhed,launched lavae,larvae +lavel,level,laravel +laveled,leveled +laveling,leveling +lavelling,levelling +lavels,levels lavendr,lavender lawernce,lawrence laybrinth,labyrinth layed,laid +lazer,laser lazyness,laziness +lcoal,local,coal +lcoally,locally +lcoation,location +lcuase,clause +leaast,least +leace,leave +leack,leak +leagacy,legacy +leagal,legal +leagalise,legalise +leagality,legality +leagalize,legalize +leagcy,legacy leage,league +leagel,legal +leagelise,legalise +leagelity,legality +leagelize,legalize +leageue,league +leagl,legal +leaglise,legalise +leaglity,legality leaglization,legalization leaglize,legalize leaglizing,legalizing -leanr,lean +leanr,lean,learn,leaner +leary,leery +leaset,least +leat,lead,leak,least,leaf leathal,lethal +leats,least +leaveing,leaving +leavong,leaving lebanesse,lebanese leceister,leicester leciester,leicester @@ -14939,7 +28486,10 @@ lefitsts,leftists lefted,left leftits,leftist leftsits,leftists +legac,legacy +legact,legacy legalazing,legalizing +legalimate,legitimate legalizacion,legalization legalizaing,legalizing legalizaiton,legalization @@ -14947,6 +28497,8 @@ legalizare,legalize legalizate,legalize legalizaton,legalization legalizeing,legalizing +legasy,legacy +legel,legal legenadries,legendaries legendaies,legendaries legendaires,legendaries @@ -14987,6 +28539,7 @@ legitimatelly,legitimately legitimatley,legitimately legitimatly,legitimately legitimetly,legitimately +legitimiately,legitimately legitimicy,legitimacy legitimite,legitimate legitimitely,legitimately @@ -14994,22 +28547,54 @@ legitimt,legitimate legitmate,legitimate legnedaries,legendaries legnedary,legendary +legnth,length legnths,lengths legnthy,lengthy legoins,legions +legth,length +leibnitz,leibniz +leightweight,lightweight leigons,legions leiutenant,lieutenant lengedaries,legendaries +lenggth,length +lengh,length +lenghs,lengths lenght,length +lenghten,lengthen +lenghtend,lengthened +lenghtened,lengthened +lenghtening,lengthening +lenghth,length +lenghthen,lengthen +lenghths,lengths +lenghthy,lengthy +lenghtly,lengthy lenghts,lengths +lenghty,lengthy +lengt,length +lengten,lengthen +lengtext,longtext lengthes,lengths +lengthh,length lengthly,lengthy +lengts,lengths +leniant,lenient +leninent,lenient lenoard,leonard +lentgh,length +lentghs,lengths +lenth,length +lenths,lengths lentiles,lentils lentills,lentils lepoard,leopard leran,learn +leraned,learned lerans,learns +lern,learn,lean +lerned,learned,learned,leaned +lerning,learning,leaning lesbain,lesbian lesbains,lesbians lesbianas,lesbians @@ -15019,9 +28604,13 @@ lesbianus,lesbians lesiban,lesbian lesibans,lesbians lesiure,leisure +lesstiff,lesstif +letgitimate,legitimate letivicus,leviticus +letmost,leftmost leuitenant,lieutenant leutenant,lieutenant +levae,leave,levee levaithan,leviathan levander,lavender levelign,leveling @@ -15032,14 +28621,24 @@ levetates,levitates levetating,levitating leviathn,leviathan levicitus,leviticus +levl,level levle,level levleing,leveling levleling,leveling +lexial,lexical +leyer,layer +leyered,layered +leyering,layering +leyers,layers lfiesteal,lifesteal +liares,liars liasion,liaison liason,liaison liasons,liaisons +libarary,library +libaries,libraries libary,library +libell,libel liberacion,liberation liberae,liberate liberales,liberals @@ -15059,6 +28658,8 @@ liberatore,liberate liberatrian,libertarians liberatrianism,libertarianism liberatrians,libertarians +liberoffice,libreoffice +liberry,library libertae,liberate libertairan,libertarians libertania,libertarians @@ -15087,23 +28688,66 @@ libertea,liberate liberterian,libertarian liberterianism,libertarianism liberterians,libertarians +libgng,libpng libguistic,linguistic libguistics,linguistics libitarianisn,libertarianism -lible,libel +lible,libel,liable +libraarie,library +libraaries,libraries +libraary,library +librabarie,library +librabaries,libraries +librabary,library +librabie,library +librabies,libraries +librabrie,library +librabries,libraries +librabry,library +libraby,library +libraie,library +libraier,library +libraies,libraries +libraiesr,libraries +libraire,library libraires,libraries +librairies,libraries +librairy,library +libralie,library +libralies,libraries +libraly,library +libraris,libraries +librarries,libraries +librarry,library librarse,libraries +libratie,library +libraties,libraries +libraty,library +libray,library +librayr,library +libreoffie,libreoffice +libreoficekit,libreofficekit +libreries,libraries +librery,library libretarian,libertarian libretarianism,libertarianism libretarians,libertarians +libries,libraries +licate,locate +licated,located +lication,location +lications,locations +licenceing,licencing licencie,licence licencse,licence +licese,license liebrals,liberals liecester,leicester lieing,lying liek,like liekable,likable liekd,liked +lient,client,clients lienups,lineups liesure,leisure lietuenant,lieutenant @@ -15114,8 +28758,12 @@ lieutenat,lieutenant lieutenent,lieutenant lieutennant,lieutenant lieutentant,lieutenant +liev,live lieved,lived +lifceycle,lifecycle +lifecyle,lifecycle lifepsan,lifespan +lifes,lives lifespawn,lifespan lifestel,lifesteal lifestiles,lifestyles @@ -15127,6 +28775,9 @@ lifesytles,lifestyles lifetimers,lifetimes lifetsyles,lifestyles liftime,lifetime +ligh,light,lie,lye +ligher,lighter,liar,liger +lighers,lighters,liars,ligers lighhtning,lightening lighitng,lighting lighlty,lightly @@ -15151,11 +28802,14 @@ lightnting,lightening lightres,lighters lightrom,lightroom lightrooom,lightroom +lightweigh,lightweight lightweigt,lightweight lightweigth,lightweight lightwieght,lightweight +lightwight,lightweight lightwright,lightweight ligitation,litigation +ligth,light ligthening,lightening ligthers,lighters ligthhouse,lighthouse @@ -15164,23 +28818,63 @@ ligthly,lightly ligthning,lightning ligthroom,lightroom ligthweight,lightweight +lik,like,lick,link likebale,likeable +likeley,likely likelyhood,likelihood +likewis,likewise +likly,likely +lileral,literal limination,limitation +liminted,limited limitacion,limitation +limitaion,limitation limitaiton,limitation limitaitons,limitation limitant,militant limitating,limitation limitativo,limitation limitato,limitation +limite,limit +limitiaion,limitation +limitiaions,limitations +limitiation,limitation +limitiations,limitations +limitied,limited +limitier,limiter +limitiers,limiters +limitiing,limiting +limitimg,limiting +limition,limitation +limitions,limitations +limitis,limits +limititation,limitation +limititations,limitations +limitited,limited +limititer,limiter +limititers,limiters +limititing,limiting +limitted,limited +limk,link +limted,limited +limti,limit +limts,limits +lincese,license +lincesed,licensed +linceses,licenses linclon,lincoln lincolin,lincoln lincolon,lincoln +linearily,linearly,linearity +linerisation,linearisation +linerisations,linearisations lineupes,lineups +linewdith,linewidth +linez,lines lingeire,lingerie lingerine,lingerie lingiere,lingerie +lingth,length linguisics,linguistics linguisitc,linguistics linguisitcs,linguistics @@ -15194,26 +28888,46 @@ linguitics,linguistic lingusitic,linguistics lingusitics,linguistics lingvistic,linguistic +linheight,lineheight +linke,linked +linkfy,linkify linnaena,linnaean +lintain,lintian linueps,lineups +linz,lines liousville,louisville +lippizaner,lipizzaner lipstics,lipsticks liqiuds,liquids liquidas,liquids liquides,liquids liquidos,liquids -liscense,license -lisence,licence +liscense,license,license +lisence,licence,licence lisenced,silenced -lisense,license +lisense,license,license +lisetning,listening +lising,listing lispticks,lipsticks +listapck,listpack +listbbox,listbox +listeing,listening listend,listened listenend,listened listeneres,listeners listenes,listens +listensers,listeners +listenter,listener +listenters,listeners listents,listens +listernes,listeners +listner,listener listners,listeners +litaral,literal +litarally,literally +litarals,literals litature,literature +liteautrue,literature litecion,litecoin litecon,litecoin liteicon,litecoin @@ -15241,10 +28955,21 @@ lithunaia,lithuania litigatin,litigation litigato,litigation litihum,lithium +litle,little litllefinger,littlefinger +litquid,liquid +litquids,liquids +lits,list +litte,little littel,little +littele,little littelfinger,littlefinger +littelry,literally +litteral,literal litterally,literally +litterals,literals +litterate,literate +litterature,literature litterfinger,littlefinger littiefinger,littlefinger littlefiger,littlefinger @@ -15256,6 +28981,8 @@ lituhania,lithuania liuetenant,lieutenant liuke,like liveatream,livestream +liveing,living +livel,level livelehood,livelihood liveprool,liverpool liverpol,liverpool @@ -15264,45 +28991,135 @@ livescream,livestream livestreem,livestream livestrem,livestream livestrems,livestream +livetime,lifetime livilehood,livelihood livley,lively livliehood,livelihood +lizens,license +lizense,license +lizensing,licensing +lke,like lmits,limits lnowledgable,knowledgable +loaader,loader +loacal,local +loacality,locality +loacally,locally +loacation,location +loaction,location +loactions,locations +loadig,loading +loadin,loading +loadning,loading loadous,loadouts lobbyistes,lobbyists lobbysits,lobbyists +locae,locate +locaes,locates +locahost,localhost +locaiing,locating +locailty,locality +locaing,locating +locaion,location +locaions,locations +locaise,localise +locaised,localised +locaiser,localiser +locaises,localises +locaite,locate +locaites,locates +locaiting,locating +locaition,location +locaitions,locations +locaiton,location +locaitons,locations +locaize,localize +locaized,localized +locaizer,localizer +locaizes,localizes +localation,location +localed,located +localtion,location +localtions,locations +localzation,localization +locatins,locations +loccked,locked +locgical,logical lockacreen,lockscreen +lockingf,locking lockscreeen,lockscreen lockscren,lockscreen +lod,load +loding,loading loenard,leonard loepard,leopard loev,love +logarithmical,logarithmically +logaritmic,logarithmic +logcal,logical +loged,logged,lodged,longed +loger,logger,lodger,longer +loggging,logging +loggin,login,logging +logicaly,logically +logictech,logitech logictical,logistical +logile,logfile +loging,logging,lodging logisitcal,logistical logisitcs,logistics logisticas,logistics logisticly,logistical logiteh,logitech +logitude,longitude +logoic,logic +logrithm,logarithm logsitics,logistics logtiech,logitech +logwritter,logwriter +loign,login loiusiana,louisiana loiusville,louisville +lokal,local +lokale,locale +lokaly,locally +lolal,total lollipoop,lollipop lollipoopy,lollipop +lonber,longer +lond,long lonelyness,loneliness +longe,longer,lounge +longers,longer longevitity,longevity longevitiy,longevity longitme,longtime longitudonal,longitudinal +longitue,longitude +longitute,longitude +longst,longest longtiem,longtime +longuer,longer lonileness,loneliness lonley,lonely lonlieness,loneliness -lonly,lonely +lonly,lonely,only +loobpack,loopback +lookes,looks +looknig,looking +looop,loop +loopup,lookup looseley,loosely loosley,loosely +loosly,loosely +loosy,lossy,lousy loreplay,roleplay +losd,lost,loss,lose,load +losely,loosely +losen,loosen +losened,loosened +losted,listed,lost,lasted +lotation,rotation,flotation lotharingen,lothringen louieville,louisville louisiania,louisiana @@ -15312,6 +29129,11 @@ louisviile,louisville louisvile,louisville louisvillle,louisville lousiville,louisville +lowd,load,low,loud +lpatform,platform +lsat,last,slat,sat +lsit,list,slit,sit +lsits,lists,slits,sits luanched,launched luancher,launcher luanchers,launchers @@ -15328,23 +29150,45 @@ ludcrious,ludicrous ludricous,ludicrous luicfer,lucifer luietenant,lieutenant -lukid,likud +lukid,likud,lucid +luminose,luminous +luminousity,luminosity lunaticos,lunatics lunaticus,lunatics lunatis,lunatics lveo,love lvoe,love lybia,libya +maake,make +mabe,maybe +mabye,maybe mabyelline,maybelline macarino,macaroni macaronni,macaroni +maccro,macro +maccros,macros +machanism,mechanism +machanisms,mechanisms +mached,matched +maches,matches machiens,machines -maching,machine +machinary,machinery +maching,machine,marching,matching machins,machines mackeral,mackerel maclolm,malcolm +maco,macro +macor,macro +macors,macros +macpakge,package +macroses,macros +macrow,macro +macthing,matching macthup,matchup macthups,matchups +madantory,mandatory +madatory,mandatory +maddness,madness madsion,madison madturbating,masturbating madturbation,masturbation @@ -15353,6 +29197,7 @@ magainzes,magazines magasine,magazine magazins,magazines magensium,magnesium +magent,magenta,magnet magentic,magnetic magents,magnets magicain,magician @@ -15362,6 +29207,8 @@ maginficent,magnificent magintude,magnitude magisine,magazine magizine,magazine +magnatiude,magnitude +magnatude,magnitude magneficent,magnificent magneisum,magnesium magnesuim,magnesium @@ -15377,12 +29224,19 @@ magnited,magnitude magnitudine,magnitude magnitue,magnitude magolia,magnolia +mahcine,machine +maibe,maybe +maibox,mailbox maidson,madison +mailformed,malformed +mailling,mailing mailny,mainly mainfest,manifest mainfestation,manifestation mainfesto,manifesto mainfests,manifests +maininly,mainly +mainling,mailing mainpulate,manipulate mainstreem,mainstream mainstrem,mainstream @@ -15396,10 +29250,15 @@ maintainted,maintained maintan,maintain maintanance,maintenance maintance,maintenance +maintane,maintain maintanence,maintenance +maintaner,maintainer +maintaners,maintainers +maintans,maintains maintenace,maintenance maintenaince,maintenance maintenence,maintenance +maintiain,maintain maintian,maintain maintianed,maintained maintianing,maintaining @@ -15408,12 +29267,27 @@ maintinaing,maintaining maintinance,maintenance maintinence,maintenance maintioned,mentioned +mairabd,mariadb +mairadb,mariadb mairjuana,marijuana mairlyn,marilyn +maitain,maintain +maitainance,maintenance +maitained,maintained +maitainers,maintainers majoroty,majority -maked,marked +maka,make +maked,marked,made +makefle,makefile +makeing,making +makign,making +makro,macro +makros,macros +makrs,makes,makers,macros makrsman,marksman -makse,makes +maks,mask,masks,makes,make +makse,makes,masks +makss,masks,makes malaira,malaria malariya,malaria malasiya,malaysia @@ -15424,6 +29298,7 @@ malayisan,malaysian malaysa,malaysia malaysain,malaysian malclom,malcolm +malcom,malcolm maletonin,melatonin malfonction,malfunction malfucntion,malfunction @@ -15432,14 +29307,20 @@ malfuncion,malfunction malfunciton,malfunction malfuncting,malfunction malfunktion,malfunction +malicous,malicious +malicously,maliciously +malplace,misplace +malplaced,misplaced malpractce,malpractice malpractise,malpractice malpractive,malpractice maltesian,maltese malyasia,malaysia malyasian,malaysian +mamagement,management mamal,mammal mamalian,mammalian +mamory,memory manadrin,mandarin manafactured,manufactured manafacturer,manufacturer @@ -15447,9 +29328,20 @@ manafacturers,manufacturers manafactures,manufactures manafacturing,manufacturing manafestation,manifestation -managable,manageable +managable,manageable,manageably +managament,management managebale,manageable +manageed,managed +managemenet,management +managenment,management +managmenet,management managment,management +manal,manual +manange,manage +manangement,management +mananger,manager +manangers,managers +manaul,manual manaully,manually manauls,manuals mandarian,mandarin @@ -15457,11 +29349,14 @@ mandarijn,mandarin mandarion,mandarin mandase,mandates mandaste,mandates +mandatatory,mandatory mandats,mandates +mandetory,mandatory mandrain,mandarin mandrian,mandarin maneagable,manageable manefestation,manifestation +manement,management maneouvre,manoeuvre maneouvred,manoeuvred maneouvres,manoeuvres @@ -15476,18 +29371,28 @@ manfiest,manifest manfiesto,manifesto manfiests,manifests manfuacturers,manufactures +mangaed,managed +mangaement,management +mangaer,manager,manger +mangaers,managers,mangers +mangager,manager +mangagers,managers mangeld,mangled +mangement,management +mangementt,management mangesium,magnesium mangetic,magnetic mangets,magnets mangitude,magnitude manglade,mangled +manifacture,manufacture manifactured,manufactured manifacturer,manufacturer manifacturers,manufacturers manifactures,manufactures manifacturing,manufacturing manifastation,manifestation +manifect,manifest manifeso,manifesto manifestacion,manifestation manifestado,manifesto @@ -15517,7 +29422,7 @@ manipulacion,manipulation manipulant,manipulate manipulare,manipulate manipulatie,manipulative -manipulatin,manipulation +manipulatin,manipulation,manipulating manipulationg,manipulating manipulaton,manipulation manipule,manipulate @@ -15526,28 +29431,51 @@ manipulted,manipulated manisfestations,manifestations maniuplate,manipulate maniuplated,manipulated +maniuplates,manipulates maniuplating,manipulating maniuplation,manipulation +maniuplations,manipulations maniuplative,manipulative +maniuplator,manipulator +maniuplators,manipulators mannarisms,mannerisms mannerisims,mannerisms mannersims,mannerisms +mannor,manner mannorisms,mannerisms +mannual,manual +mannually,manually +mannualy,manually manoeuverability,maneuverability -manouver,maneuver -manouverability,maneuverability -manouverable,maneuverable -manouvers,maneuvers +manouevring,manoeuvring +manouver,maneuver,maneuver +manouverability,maneuverability,maneuverability +manouverable,maneuverable,maneuverable +manouvers,maneuvers,maneuvers mansalughter,manslaughter manslaugher,manslaughter manslaugter,manslaughter manslaugther,manslaughter mansluaghter,manslaughter +mantain,maintain +mantainable,maintainable mantained,maintained +mantainer,maintainer +mantainers,maintainers +mantaining,maintaining +mantains,maintains +mantanine,maintain +mantanined,maintained +mantatory,mandatory +mantenance,maintenance manuales,manuals manualy,manually -manuever,maneuver -manuevers,maneuvers +manualyl,manually +manualyy,manually +manuell,manual +manuelly,manually +manuever,maneuver,maneuver +manuevers,maneuvers,maneuvers manufacter,manufacture manufactered,manufactured manufacterer,manufacturer @@ -15596,13 +29524,33 @@ manufacutres,manufactures manufature,manufacture manufatured,manufactured manufaturing,manufacturing +manufaucturing,manufacturing manufcaturers,manufactures +manulally,manually +manully,manually manupilated,manipulated manupilating,manipulating +manupilations,manipulations +manupulate,manipulate +manupulated,manipulated +manupulates,manipulates manupulating,manipulating manupulation,manipulation +manupulations,manipulations manupulative,manipulative manuver,maneuver +manyal,manual +manyally,manually +manyals,manuals +mapable,mappable +mape,map +maped,mapped +maping,mapping +mapings,mappings +mapp,map +mappeds,mapped +mappping,mapping +mapppings,mappings maraconi,macaroni maradeur,marauder maraduer,marauder @@ -15619,18 +29567,22 @@ margarent,margaret margaritte,margaret margart,margaret margenalized,marginalized +marger,merger,marker margerat,margaret +margers,mergers,markers margianlly,marginally marginaal,marginal marginaali,marginal marginable,marginal marginaly,marginally margines,margins +marging,margin,merging margings,margins marginilized,marginalized marginis,margins marhsmallow,marshmallow marhsmallows,marshmallows +mariabd,mariadb mariage,marriage mariens,marines marignal,marginal @@ -15653,7 +29605,7 @@ markedet,marketed markeras,markers markerplace,marketplace markerts,markers -markes,marks +markes,marks,marked,markers marketpalce,marketplace marketting,marketing marlbes,marbles @@ -15676,16 +29628,30 @@ marshmalows,marshmallows marskman,marksman martail,martial martain,martian +marter,martyr maruader,marauder marvelos,marvelous marxisim,marxism masacra,mascara +masakist,masochist mascarra,mascara masculanity,masculinity masculenity,masculinity masculinty,masculinity +mashetty,machete +mashine,machine +mashined,machined +mashines,machines +masia,messiah +masicer,massacre +masiff,massif +maskerading,masquerading +maskeraid,masquerade masoginistic,misogynistic masogynistic,misogynistic +masos,macos +masquarade,masquerade +masqurade,masquerade masrhmallow,marshmallow massace,massacre massacer,massacre @@ -15701,13 +29667,18 @@ massachussets,massachusetts massachussetts,massachusetts massachustts,massachusetts massacrare,massacre +massagebox,messagebox massagens,massages massarce,massacre massasge,massages masscare,massacre massechusetts,massachusetts +massectomy,mastectomy +massewer,masseur massivelly,massively massivley,massively +masster,master +masteer,master masteires,masteries masterbation,masturbation mastereis,masteries @@ -15722,6 +29693,7 @@ masterpeice,masterpiece masterpeices,masterpiece masterpice,masterpiece mastieres,masteries +mastquerade,masquerade mastrubate,masturbate mastrubated,masturbated mastrubates,masturbate @@ -15755,11 +29727,31 @@ masturdating,masturbating masturpiece,masterpiece mastutbation,masturbation masuclinity,masculinity +mata,meta,mater +matadata,metadata +matainer,maintainer +matainers,maintainers mataphorical,metaphorical mataphorically,metaphorically mataphysical,metaphysical +matatable,metatable +matc,match matchamking,matchmaking +matchies,matches +matchign,matching +matchin,matching matchmakeing,matchmaking +matchs,matches +matcing,matching +mateial,material,metal +mateials,materials,metals +mateiral,material +mateirals,materials +matemathical,mathematical +materaial,material +materaials,materials +materail,material +materails,materials materalists,materialist materiaal,material materiales,materials @@ -15767,13 +29759,23 @@ materialisimo,materialism materialsim,materialism materialsm,materialism materias,materials +materiasl,materials,material +materil,material +materilism,materialism +materilize,materialize +materils,materials +materla,material +materlas,materials mathamatician,mathematician mathamatics,mathematics mathametician,mathematician mathameticians,mathematicians +mathces,matches +mathcing,matching mathcmaking,matchmaking mathcup,matchup mathcups,matchups +mathed,matched mathemagically,mathematically mathemagics,mathematics mathemathics,mathematics @@ -15793,29 +29795,52 @@ mathemetically,mathematically mathemetician,mathematician mathemeticians,mathematicians mathemetics,mathematics +mathes,matches +mathetician,mathematician matheticians,mathematicians mathewes,mathews +mathimatic,mathematic mathimatical,mathematical mathimatically,mathematically +mathimatician,mathematician +mathimaticians,mathematicians mathimatics,mathematics +mathing,matching +mathmatical,mathematical mathmatically,mathematically mathmatician,mathematician mathmaticians,mathematicians +mathod,method mathwes,mathews matieral,material matieralism,materialism matierals,materials +matix,matrix matrial,martial +matser,master matterss,mattress mattreses,mattress +matzch,match mauarder,marauder +maube,maybe,mauve maunals,manuals +mavrick,maverick maximazing,maximizing +maximim,maximum +maximimum,maximum maximini,maximizing +maximium,maximum maximixing,maximizing +maximun,maximum +maxinum,maximum +maxium,maximum +maxiumum,maximum +maxosx,macosx +maxumum,maximum mayalsia,malaysia mayalsian,malaysian mayballine,maybelline +maybee,maybe maybelle,maybelline maybelleine,maybelline maybellene,maybelline @@ -15826,33 +29851,96 @@ maybellline,maybelline maybilline,maybelline maylasia,malaysia maylasian,malaysian +mayu,may +mazilla,mozilla mcalren,mclaren mccarhty,mccarthy mccarthey,mccarthy mccarthyst,mccarthyist mcgergor,mcgregor +mchanic,mechanic +mchanical,mechanical +mchanically,mechanically +mchanicals,mechanicals mchanics,mechanics +mchanism,mechanism +mchanisms,mechanisms mclarean,mclaren mcreggor,mcgregor +mcroscope,microscope +mcroscopes,microscopes +mcroscopic,microscopic +mcroscopies,microscopies +mcroscopy,microscopy mdifielder,midfielder mdifielders,midfielders +mdoel,model +mdoeled,modeled +mdoeling,modeling +mdoelled,modelled +mdoelling,modelling +mdoels,models +meachanism,mechanism +meachanisms,mechanisms +meachinism,mechanism +meachinisms,mechanisms +meachnism,mechanism +meachnisms,mechanisms +meading,meaning meagthread,megathread meagtron,megatron +meaing,meaning meancing,menacing +meanigfull,meaningful +meanign,meaning +meanin,meaning +meaninful,meaningful meaningess,meanings +meaningfull,meaningful meaningles,meanings +meanining,meaning +meaninless,meaningless meaninng,meaning meanins,meanings +mear,wear,mere,mare +mearly,merely,nearly +measurd,measured,measure +measuremenet,measurement +measuremenets,measurements +measurmenet,measurement +measurmenets,measurements +measurment,measurement +measurments,measurements +meatadata,metadata meatballers,meatballs meatballls,meatballs meatbals,meatballs +meatfile,metafile +meathod,method +meauring,measuring +meausure,measure +meausures,measures +meber,member +mebmer,member +mebrain,membrane +mebrains,membranes +mebran,membrane +mebrans,membranes +mecahinsm,mechanism +mecahinsms,mechanisms mecahnic,mechanic mecahnical,mechanical mecahnically,mechanically mecahnics,mechanics +mecahnism,mechanism mecahnisms,mechanisms +mecanism,mechanism +mecanisms,mechanisms mecernaries,mercenaries mecernary,mercenary +mechamism,mechanism +mechamisms,mechanisms +mechananism,mechanism mechancial,mechanical mechancially,mechanically mechancis,mechanics @@ -15867,22 +29955,31 @@ mechanicly,mechanical mechanicsms,mechanisms mechanicus,mechanics mechanim,mechanism -mechanims,mechanism +mechanims,mechanism,mechanisms mechaninc,mechanic mechanincs,mechanic -mechanis,mechanics +mechanis,mechanics,mechanism mechanisim,mechanism mechanisims,mechanism mechanismus,mechanisms mechansim,mechanism mechansims,mechanisms +mechine,machine +mechines,machines mechinical,mechanical +mechinism,mechanism mechinisms,mechanisms +mechnanism,mechanism +mechnism,mechanism +mechnisms,mechanisms medacine,medicine +medai,media medatite,meditate medeival,medieval medeterranean,mediterranean medevial,medieval +medhod,method +medhods,methods mediaction,medications mediavel,medieval medicacion,medication @@ -15898,7 +29995,7 @@ mediciad,medicaid medicince,medicine medicinens,medicines medicineras,medicines -mediciney,mediciny +mediciney,mediciny,medicine,medicinal medicins,medicines medicinske,medicine medicore,mediocre @@ -15932,9 +30029,18 @@ mediterranen,mediterranean mediterrannean,mediterranean mediveal,medieval medoicre,mediocre +meeds,needs +meens,means meerkrat,meerkat +meetign,meeting +meganism,mechanism megathred,megathread megatorn,megatron +mege,merge +mehods,methods +mehtod,method +mehtods,methods +meida,media meidcare,medicare meixcan,mexican meixcans,mexicans @@ -15950,31 +30056,78 @@ mellinnium,millennium melodieuse,melodies melodis,melodies meltodwn,meltdown +membran,membrane membranaphone,membranophone membrance,membrane membrances,membrane +membrans,membranes +memcahe,memcache +memcahed,memcached +memeasurement,measurement memeber,member +memebered,remembered +memebers,members +memebership,membership +memeberships,memberships +memebr,member +memebrof,memberof +memebrs,members +memember,member,remember +memembers,members +mememory,memory +mememto,memento +memeory,memory +memer,member memerization,memorization +memership,membership +memerships,memberships +memery,memory +memmber,member +memmory,memory memoery,memory +memomry,memory +memor,memory memorie,memory memoriez,memorize memorizacion,memorization memorozation,memorization +mempry,memory +memroy,memory menally,mentally +menas,means mencaing,menacing +menetion,mention +menetioned,mentioned +menetioning,mentioning +menetions,mentions +menion,mention,minion +menioned,mentioned +menions,mentions,minions menstraul,menstrual menstrul,menstrual menstural,menstrual mensutral,menstrual +ment,meant mentallity,mentally mentaly,mentally +menthods,methods +mentiond,mentioned +mentione,mentioned mentiones,mentions mentiong,mentioning +mentionned,mentioned mentionnes,mentions mentionning,mentioning +mentionnned,mentioned +menual,manual +menue,menu +menues,menus +menutitems,menuitems +meny,menu,many meoldic,melodic meoldies,melodies -meranda,veranda +meranda,veranda,miranda +mercahnt,merchant mercanaries,mercenaries mercaneries,mercenaries mercanery,mercenary @@ -15991,6 +30144,7 @@ merchanidse,merchandise merchanise,merchandise merchans,merchants merchanters,merchants +merchantibility,merchantability merchantos,merchants merchat,merchant merchendise,merchandise @@ -16000,19 +30154,58 @@ mercineries,mercenaries mercurcy,mercury mercurey,mercury merficul,merciful +mergable,mergeable +merget,merge +mergge,merge +mergged,merged +mergging,merging merhcant,merchant merhcants,merchants mericful,merciful +merly,merely +mermory,memory +merory,memory +merrors,mirrors merucry,mercury +mesage,message +mesages,messages +mesaureed,measured +meshe,mesh,meshed,meshes +messag,message messagd,messaged messagease,messages messagepad,messaged messagers,messages +messagetqueue,messagequeue +messagin,messaging +messagoe,message +messags,messages +messagses,messages messaih,messiah messanger,messenger +messangers,messengers +messave,message messenging,messaging messgaed,messaged +messgaes,messages +messge,message +messges,messages messiach,messiah +messsage,message +messsages,messages +messure,measure +messured,measured +messurement,measurement +messures,measures +messuring,measuring +messurment,measurement +mesure,measure +mesured,measured +mesurement,measurement +mesurements,measurements +mesures,measures +mesuring,measuring +mesurment,measurement metabalism,metabolism metabilism,metabolism metabloic,metabolic @@ -16023,6 +30216,8 @@ metabolisim,metabolism metabolitic,metabolic metabolizm,metabolism metabolsim,metabolism +metacharater,metacharacter +metacharaters,metacharacters metagaem,metagame metagem,metagame metahpor,metaphor @@ -16032,9 +30227,12 @@ metalurgical,metallurgical metalurgy,metallurgy metamage,metagame metamorphysis,metamorphosis +metapackge,metapackage +metapackges,metapackages metaphisical,metaphysical metaphisics,metaphysics metaphoras,metaphors +metaphore,metaphor metaphores,metaphors metaphorial,metaphorical metaphoricaly,metaphorically @@ -16051,9 +30249,14 @@ metaphyscial,metaphysical metaphysicals,metaphysics metaphysicans,metaphysics metaphysisch,metaphysics +metaprogamming,metaprogramming +metatdata,metadata +metdata,metadata metephorical,metaphorical metephorically,metaphorically metephysical,metaphysical +meterial,material +meterials,materials meterologist,meteorologist meterology,meteorology meterosexual,heterosexual @@ -16064,16 +30267,32 @@ methapor,metaphor methaporical,metaphorical methaporically,metaphorically methapors,metaphors +methd,method +methds,methods methematical,mathematical methematician,mathematician +methid,method +methids,methods +methjod,method +methodd,method +methode,method +methoden,methods methodolgy,methodology methodoligy,methodology methodoloy,methodology methodoly,methodology +methodss,methods metholodogy,methodology +methos,methods,method +methot,method +methots,methods +metion,mention +metioned,mentioned metiphorical,metaphorical metiphorically,metaphorically metldown,meltdown +metod,method +metods,methods metophorical,metaphorical metophorically,metaphorically metorpolitan,metropolitan @@ -16111,31 +30330,62 @@ mexicanese,mexicans mexicaness,mexicans mexicants,mexicans mexicanus,mexicans +meybe,maybe mhytical,mythical +miagic,magic +miagical,magical +mial,mail +mices,mice michagan,michigan michelline,michelle michellle,michelle michgian,michigan michina,michigan micorcenter,microcenter +micorcode,microcode +micorcodes,microcodes micorphones,microphones +micorsoft,microsoft micortransactions,microtransactions micorwave,microwave micorwaves,microwaves +micoscope,microscope +micoscopes,microscopes +micoscopic,microscopic +micoscopies,microscopies micoscopy,microscopy +micosoft,microsoft +micrcontroller,microcontroller +micrcontrollers,microcontrollers microcender,microcenter microcentre,microcenter microcentres,microcenter microcentro,microcenter +microcontroler,microcontroller +microcontrolers,microcontrollers +microfost,microsoft microhpone,microphone microhpones,microphones +microntroller,microcontroller +microntrollers,microcontrollers microphen,microphone microphonies,microphones +micropone,microphone +micropones,microphones +microprocesspr,microprocessor +microprocessprs,microprocessors microscoop,microscope microscophic,microscopic microscopice,microscope microscoptic,microscopic microscrope,microscope +microseond,microsecond +microseonds,microseconds +microsft,microsoft +microship,microchip +microships,microchips +microsof,microsoft +microsofot,microsoft microstansactions,microtransactions microtax,microatx microtramsactions,microtransactions @@ -16163,6 +30413,8 @@ microwae,microwaves microwavees,microwaves microwavers,microwaves micrpohone,microphones +micrsft,microsoft +micrsoft,microsoft midfeild,midfield midfeilder,midfielder midfeilders,midfielders @@ -16178,6 +30430,7 @@ midfileders,midfielders midifeld,midfield midifelder,midfielder midifelders,midfielders +midified,modified midnlessly,mindlessly midotwn,midtown midtwon,midtown @@ -16186,8 +30439,26 @@ migrainers,migraines migrains,migraines migrans,migrants migrantes,migrants +migrateable,migratable migriane,migraine migrianes,migraines +migt,might,midget +migth,might +miinimisation,minimisation +miinimise,minimise +miinimised,minimised +miinimises,minimises +miinimising,minimising +miinimization,minimization +miinimize,minimize +miinimized,minimized +miinimizes,minimizes +miinimizing,minimizing +miinimum,minimum +mikrosecond,microsecond +mikroseconds,microseconds +milage,mileage +milages,mileages milawukee,milwaukee mileau,milieu milennia,millennia @@ -16195,24 +30466,37 @@ milennium,millennium milestons,milestones miletsones,milestones mileu,milieu +miliary,military miligram,milligram miliitas,militias +milimeter,millimeter +milimeters,millimeters +milimetre,millimetre +milimetres,millimetres +milimiters,millimeters milion,million miliraty,military milisecond,millisecond +miliseconds,milliseconds +milisecons,milliseconds militais,militias militat,militant militiades,militias militians,militias militiants,militias militis,militias +milivolts,millivolts +milleneum,millennium millenia,millennia millenial,millennial millenialism,millennialism +millenials,millennials millenian,millennia millenium,millennium millenna,millennia millienaire,millionaire +milliescond,millisecond +milliesconds,milliseconds millinnium,millennium millionairre,millionaire millionairres,millionaire @@ -16222,15 +30506,45 @@ millionarie,millionaire millionaries,millionaires millioniare,millionaire millioniares,millionaires +millisencond,millisecond +millisenconds,milliseconds +milliseond,millisecond +milliseonds,milliseconds +millitant,militant millitary,military millon,million +millsecond,millisecond +millseconds,milliseconds +millsencond,millisecond +millsenconds,milliseconds miltary,military miltiant,militant +miltisite,multisite miluwakee,milwaukee milwakuee,milwaukee milwuakee,milwaukee +mimach,mismatch +mimachd,mismatched +mimached,mismatched +mimaches,mismatches +mimaching,mismatching +mimatch,mismatch +mimatchd,mismatched +mimatched,mismatched +mimatches,mismatches +mimatching,mismatching +mimicing,mimicking +mimick,mimic +mimicks,mimics +mimimal,minimal +mimimise,minimise,minimise +mimimize,minimize,minimize mimimum,minimum +mimimun,minimum +miminal,minimal miminalist,minimalist +miminally,minimally +miminaly,minimally minamilist,minimalist minature,miniature mindcarck,mindcrack @@ -16242,6 +30556,7 @@ mindlessy,mindlessly minerales,minerals mineras,minerals minerial,mineral +minggw,mingw mingiame,minigame minimage,minigame minimalisitc,minimalist @@ -16249,31 +30564,55 @@ minimalisity,minimalist minimals,minimalist minimalstic,minimalist minimalt,minimalist +minimam,minimum minimazing,minimizing +minimial,minimal minimilast,minimalist minimilist,minimalist minimini,minimizing minimium,minimum +minimsation,minimisation +minimse,minimise +minimsed,minimised +minimses,minimises +minimsing,minimising +minimumm,minimum +minimumn,minimum +minimun,minimum +minimzation,minimization +minimze,minimize +minimzed,minimized +minimzes,minimizes +minimzing,minimizing +mininal,minimal mininalist,minimalist mininos,minions mininterpret,misinterpret mininterpreting,misinterpreting +mininum,minimum minipulating,manipulating minipulation,manipulation minipulative,manipulative minisclue,miniscule miniscue,miniscule miniscuel,miniscule +miniscully,minusculely ministerens,ministers ministeres,ministers ministerios,ministers ministerns,ministers -ministery,ministry +ministery,ministry,minister ministr,minister ministy,ministry minisucle,miniscule minitaure,miniature minituare,miniature +miniture,miniature +minium,minimum +miniums,minimums +miniumum,minimum +minmal,minimal +minmum,minimum minneaoplis,minneapolis minneaplis,minneapolis minneaplois,minneapolis @@ -16292,7 +30631,16 @@ minsiters,ministers minsitry,ministry minstries,ministries minstry,ministry +mintor,mentor,monitor +mintored,mentored,monitored +mintoring,mentoring,monitoring +mintors,mentors,monitors +minum,minimum minumum,minimum +minuscle,minuscule +minusculy,minusculely,minuscule +minuts,minutes +miplementation,implementation miracalous,miraculous miracilously,miraculously miracluous,miraculous @@ -16307,21 +30655,40 @@ miralces,miracles mircales,miracles mircoatx,microatx mircocenter,microcenter +mirconesia,micronesia mircophone,microphone mircophones,microphones mircoscope,microscope +mircoscopes,microscopes mircoscopic,microscopic +mircosoft,microsoft mircotransaction,microtransactions mircotransactions,microtransactions mircowave,microwave mircowaves,microwaves mirgaine,migraine +mirgate,migrate +mirgated,migrated +mirgates,migrates +miror,mirror,minor +mirored,mirrored +miroring,mirroring +mirorr,mirror mirorred,mirrored +mirorring,mirroring +mirorrs,mirrors +mirors,mirrors,minors +mirro,mirror +mirroed,mirrored mirrord,mirrored +mirrorn,mirror mirrorred,mirrored +misalignement,misalignment +misalinged,misaligned misanderstood,misunderstood misandrony,misandry misandy,misandry +misbehaive,misbehave miscairrage,miscarriage miscarrage,miscarriage miscarraige,miscarriage @@ -16330,9 +30697,11 @@ miscarridge,miscarriage miscarriege,miscarriage miscarrige,miscarriage miscatalogued,miscataloged +misceancellous,miscellaneous miscelaneous,miscellaneous miscellanious,miscellaneous miscellanous,miscellaneous +miscelleneous,miscellaneous mischeivous,mischievous mischevious,mischievous mischievious,mischievous @@ -16344,7 +30713,9 @@ miscommuniction,miscommunication miscomunnication,miscommunication misconcpetion,misconceptions misconecption,misconceptions +misconfiged,misconfigured misconseptions,misconceptions +miscrosoft,microsoft miscummunication,miscommunication misdameanor,misdemeanor misdameanors,misdemeanors @@ -16360,6 +30731,7 @@ miserabel,miserable miserablely,miserably miserabley,miserably miserablly,miserably +misformed,malformed misfortunte,misfortune misforture,misfortune misfourtunes,misfortunes @@ -16368,6 +30740,9 @@ misgoynistic,misogynistic misile,missile misimformed,misinformed misinfomed,misinformed +mising,missing +misintepret,misinterpret +misintepreted,misinterpreted misinterept,misinterpret misinterperet,misinterpret misinterpert,misinterpret @@ -16384,6 +30759,7 @@ misinterpretated,misinterpreted misinterpretating,misinterpreting misinterpretion,misinterpreting misinterpretions,misinterpreting +misinterprett,misinterpret misinterpretted,misinterpreted misinterpretting,misinterpreting misinterprit,misinterpreting @@ -16394,9 +30770,17 @@ misinterpted,misinterpret misintrepret,misinterpret misintrepreted,misinterpreted misintrepreting,misinterpreting +misisng,missing misison,mission misisonaries,missionaries misisonary,missionary +mismach,mismatch +mismached,mismatched +mismaches,mismatches +mismaching,mismatching +mismactch,mismatch +mismatchd,mismatched +mismatich,mismatch misnadry,misandry misoganist,misogynist misoganistic,misogynistic @@ -16428,6 +30812,8 @@ misoygnist,misogynist mispell,misspell mispelled,misspelled mispelling,misspelling +mispelt,misspelt +mispronounciation,mispronunciation misproportionate,disproportionate misreable,miserable misreably,miserably @@ -16441,9 +30827,18 @@ misrepresentating,misrepresenting misrepresentativ,misrepresentation misrepresention,misrepresenting misrepreseted,misrepresented +missconfiguration,misconfiguration +missconfigure,misconfigure +missconfigured,misconfigured +missconfigures,misconfigures +missconfiguring,misconfiguring +misscounted,miscounted missen,mizzen +missign,missing missigno,mission missils,missiles +missin,mission,missing +missings,missing missionaire,missionaries missionaires,missionaries missionairy,missionary @@ -16461,28 +30856,49 @@ mississipis,mississippi mississipppi,mississippi mississppi,mississippi missle,missile +missleading,misleading misslies,missiles +missmanaged,mismanaged +missmatch,mismatch +missmatchd,mismatched +missmatched,mismatched +missmatches,mismatches +missmatching,mismatching missonary,missionary missorui,missouri missourri,missouri misspeeling,misspelling +misspel,misspell misspeld,misspelled misspeling,misspelling misspelld,misspelled misspellled,misspelled misspellling,misspelling misspellng,misspelling -misspelt,misspelled +misssing,missing +misstake,mistake +misstaken,mistaken +misstakes,mistakes +misstype,mistype +misstypes,mistypes +missunderstood,misunderstood +missuse,misuse mistakedly,mistakenly mistakengly,mistakenly mistakently,mistakenly mistakey,mistakenly mistakinly,mistakenly mistankely,mistakenly +mistatch,mismatch +mistatchd,mismatched +mistatched,mismatched +mistatches,mismatches +mistatching,mismatching misterious,mysterious misteriously,mysteriously mistery,mystery misteryous,mysterious +mistmatches,mismatches mistread,mistreated mistreaded,mistreated misubderstanding,misunderstandings @@ -16522,14 +30938,45 @@ misunterstood,misunderstood misygonist,misogynist misygonistic,misogynistic mitigaiton,mitigation +mittigate,mitigate +miximum,maximum +mixted,mixed +mixure,mixture +mjor,major mkae,make mkaes,makes mkaing,making +mke,make mkea,make +mmaped,mapped +mmatching,matching +mmbers,members +mmnemonic,mnemonic +mnay,many +moast,most,moat +mobify,modify mobilitiy,mobility mobiliy,mobility mobiltiy,mobility +mocrochip,microchip +mocrochips,microchips +mocrocode,microcode +mocrocodes,microcodes +mocrocontroller,microcontroller +mocrocontrollers,microcontrollers +mocrophone,microphone +mocrophones,microphones +mocroprocessor,microprocessor +mocroprocessors,microprocessors +mocrosecond,microsecond +mocroseconds,microseconds +mocrosoft,microsoft mocrotransactions,microtransactions +mocule,module +mocules,modules +moddel,model +moddels,models +modell,model moderacion,moderation moderatedly,moderately moderaters,moderates @@ -16542,23 +30989,130 @@ moderatorin,moderation moderatorn,moderation moderats,moderates moderm,modem +modernination,modernization +moderninations,modernizations +moderninationz,modernizations +modernizationz,modernizations +modesettting,modesetting +modeul,module +modeuls,modules +modfel,model +modfiable,modifiable +modfication,modification +modfications,modifications +modfide,modified +modfided,modified +modfider,modifier +modfiders,modifiers +modfides,modifies +modfied,modified +modfieid,modified +modfieir,modifier +modfieirs,modifiers +modfieis,modifies +modfier,modifier +modfiers,modifiers +modfies,modifies +modfifiable,modifiable +modfification,modification +modfifications,modifications +modfified,modified +modfifier,modifier +modfifiers,modifiers +modfifies,modifies +modfify,modify +modfifying,modifying +modfiiable,modifiable +modfiication,modification +modfiications,modifications +modfitied,modified +modfitier,modifier +modfitiers,modifiers +modfities,modifies +modfity,modify +modfitying,modifying +modfiy,modify +modfiying,modifying +modfy,modify +modfying,modifying +modications,modifications +modifable,modifiable +modifaction,modification +modifactions,modifications +modifation,modification +modifations,modifications +modifcation,modification +modifcations,modifications +modifciation,modification +modifciations,modifications +modifcication,modification +modifcications,modifications +modifdied,modified +modifdy,modify +modifed,modified +modifer,modifier +modifers,modifiers +modifes,modifies +modiffer,modifier +modiffers,modifiers +modifiation,modification +modifiations,modifications modificacion,modification modificaiton,modification modificaitons,modifications +modificatioon,modification modificato,modification modificaton,modification modificatons,modifications +modifid,modified modifieras,modifiers modifieres,modifiers +modifified,modified +modifify,modify modifikation,modification +modifing,modifying modifires,modifiers +modifiy,modify +modifiyng,modifying +modifled,modified +modifler,modifier +modiflers,modifiers +modift,modify +modifty,modify +modifu,modify +modifuable,modifiable +modifued,modified +modifx,modify +modifyable,modifiable +modiration,moderation modivational,motivational modle,model +modlue,module +modprobbing,modprobing +modprobeing,modprobing +modtified,modified modualr,modular +modue,module +moduel,module +moduels,modules +moduile,module +modukles,modules +modul,module modulair,modular +modulie,module +modulu,modulo +modulues,modules +modyfy,modify moelcules,molecules moent,moment moeny,money +mofdified,modified +mofification,modification +mofified,modified +mofifies,modifies +mofify,modify +mohammedans,muslims +moint,mount moisterizer,moisturizer moisterizing,moisturizing moistorizing,moisturizing @@ -16584,7 +31138,12 @@ molestato,molestation molesterd,molested molestered,molested moleststion,molestation +momement,moment +momementarily,momentarily +momements,moments momemtarily,momentarily +momemtary,momentary +momemtn,moment momentairly,momentarily momentaraly,momentarily momentarely,momentarily @@ -16594,23 +31153,39 @@ momenterily,momentarily momento,memento momentos,moments momentus,moments +momery,memory momment,moment +momoent,moment +momoment,moment +momomentarily,momentarily +momomento,memento,moment +momomentos,mementos,moments +momoments,moments monagomous,monogamous monagomy,monogamy monarcy,monarchy monatge,montage +mone,mono,money,none monestaries,monasteries -monestary,monastery +monestary,monastery,monetary +monestic,monastic monetizare,monetize monglos,mongols mongoles,mongols mongolos,mongols +monitary,monetary +moniter,monitor monitering,monitoring +monitoing,monitoring monitord,monitored monitoreada,monitored monitoreado,monitored monitores,monitors monitos,monitors +monkies,monkeys +monochorome,monochrome +monochromo,monochrome +monocrome,monochrome monogameous,monogamous monogmay,monogamy monogymous,monogamous @@ -16627,6 +31202,8 @@ monolopy,monopoly monolothic,monolithic monolouge,monologue monolythic,monolithic +monontonicity,monotonicity +monopace,monospace monopilies,monopolies monoploies,monopolies monoploy,monopoly @@ -16639,6 +31216,10 @@ monopolly,monopoly monopoloy,monopoly monopols,monopolies monothilic,monolithic +monotir,monitor +monotired,monitored +monotiring,monitoring +monotirs,monitors monrachy,monarchy monserrat,montserrat monsterous,monsters @@ -16651,6 +31232,7 @@ monstrocity,monstrosity monstros,monstrous monstrosoty,monstrosity monstrostiy,monstrosity +monstrum,monster monstruos,monstrous montaban,montana montaeg,montage @@ -16666,6 +31248,7 @@ monteize,monetize monteral,montreal montioring,monitoring montiors,monitors +montly,monthly montnana,montana montrel,montreal monts,months @@ -16680,14 +31263,21 @@ monumentus,monuments monumet,monument monumnet,monument monumnets,monuments +moodify,modify moonligt,moonlight +moounting,mounting +mopdule,module +mopre,more moprhine,morphine +mor,more moratlity,mortality morbidley,morbidly morbidy,morbidly morbildy,morbidly +mordern,modern mordibly,morbidly moreso,more +morever,moreover morevoer,moreover morgage,mortgage morgatges,mortgages @@ -16695,6 +31285,12 @@ morgtages,mortgages morhpine,morphine moribdly,morbidly morisette,morissette +mormalise,normalise +mormalised,normalised +mormalises,normalises +mormalize,normalize +mormalized,normalized +mormalizes,normalizes mormones,mormons mormonisim,mormonism mormonsim,mormonism @@ -16717,8 +31313,10 @@ mortailty,mortality mortards,mortars mortarts,mortars moruning,mourning +mose,more,mouse mositurizer,moisturizer mositurizing,moisturizing +moslty,mostly mosnter,monster mosnters,monsters mosntrosity,monstrosity @@ -16728,8 +31326,15 @@ mosquitero,mosquito mosquiters,mosquitoes mosquitto,mosquito mosqutio,mosquito +mostlky,mostly mosture,moisture +mosty,mostly +motation,notation,rotation,motivation motehrboard,motherboard +moteur,motor +moteured,motored +moteuring,motoring +moteurs,motors mothebroard,motherboards motherbaord,motherboard motherbaords,motherboards @@ -16742,6 +31347,7 @@ motherborads,motherboards motherbord,motherboard motherbords,motherboards motherobard,motherboards +mothing,nothing mothreboard,motherboards motivacional,motivational motivaiton,motivations @@ -16752,7 +31358,9 @@ motivationals,motivations motivationnal,motivational motivet,motivate motiviated,motivated +motiviation,motivation motnage,montage +motononic,monotonic motoral,motorola motorcicle,motorcycle motorcicles,motorcycles @@ -16765,62 +31373,118 @@ motorolja,motorola motorollas,motorola motoroloa,motorola motovational,motivational +moudle,module +moudule,module mounment,monument mounring,mourning mountan,mountain -mounth,month +mounth,month,mouth mountian,mountain +mountpiont,mountpoint +mountpionts,mountpoints +mouspointer,mousepointer moustace,moustache moustahce,moustache mousturizing,moisturizing mouthpeace,mouthpiece mouthpeice,mouthpiece mouthpeices,mouthpiece +moutn,mount +moutned,mounted +moutning,mounting +moutnpoint,mountpoint +moutnpoints,mountpoints +moutns,mounts +movebackwrd,movebackward +moveble,movable movei,movie +movemement,movement +movemements,movements +movememnt,movement +movememnts,movements +movememt,movement +movememts,movements +movemet,movement +movemets,movements +movemment,movement +movemments,movements +movemnet,movement +movemnets,movements +movemnt,movement +movemnts,movements movepseed,movespeed movesped,movespeed movespeeed,movespeed +movied,moved,movie movment,movement +mozila,mozilla mozillia,mozilla mozillla,mozilla mozzaralla,mozzarella mozzarela,mozzarella mozzeralla,mozzarella +mozzilla,mozilla mozzorella,mozzarella mroe,more +mssing,missing msytical,mystical +mthod,method +mtuually,mutually mucisians,musicians mucnhies,munchies mucuous,mucous muder,murder mudering,murdering +mudule,module +mudules,modules muesums,museums +muext,mutex muffings,muffins muffinus,muffins muktitasking,multitasking muliple,multiple mulitated,mutilated mulitation,mutilation +mulithread,multithread mulitnational,multinational mulitnationals,multinational +mulitpart,multipart +mulitpath,multipath mulitplayer,multiplayer mulitple,multiple mulitples,multiples mulitplication,multiplication +mulitplicative,multiplicative mulitplied,multiplied mulitplier,multiplier +mulitpliers,multipliers mulitply,multiply mulitplying,multiplying mulittasking,multitasking mulitverse,multiverse mulsims,muslims +multible,multiple +multibye,multibyte +multicat,multicast multicultralism,multiculturalism +multidimensinal,multidimensional +multidimensionnal,multidimensional +multidimentionnal,multidimensional +multiecast,multicast +multifuction,multifunction +multilangual,multilingual +multile,multiple +multilpe,multiple multilpier,multiplier multimational,multinational multinatinal,multinational multinationella,multinational multipalyer,multiplayer multipe,multiple +multipes,multiples +multipiler,multiplier +multipilers,multipliers +multipl,multiple,multiply multiplaer,multiplier multiplater,multiplayer multiplaye,multiply @@ -16829,11 +31493,16 @@ multiplays,multiply multiplebgs,multiples multipled,multiplied multipleies,multiples +multipler,multiplier,multiple +multiplers,multipliers multipleye,multiply multiplicacion,multiplication multiplicaiton,multiplication multiplicativo,multiplication multiplicaton,multiplication +multipliciaton,multiplication +multiplicites,multiplicities +multiplicty,multiplicity multiplikation,multiplication multipling,multiplying multiplr,multiplier @@ -16841,14 +31510,37 @@ multipls,multiples multiplyed,multiplied multiplyer,multiple multiplyng,multiplying +multipresistion,multiprecision +multipul,multiple multipy,multiply +multipyling,multiplying multitaksing,multitasking multitaskng,multitasking +multithreded,multithreaded multitudine,multitude +multitute,multitude multiverese,multiverse -multplies,multiples +multivriate,multivariate +multixsite,multisite +multliple,multiple +multliples,multiples +multliplied,multiplied +multliplier,multiplier +multlipliers,multipliers +multliplies,multiplies +multliply,multiply +multliplying,multiplying +multple,multiple +multplied,multiplied +multplier,multiplier +multpliers,multipliers +multplies,multiples,multiplies +multply,multiply +multplying,multiplying multyplayer,multiplayer multyplying,multiplying +mumber,number +mumbers,numbers munbers,numbers munchis,munchies muncipalities,municipalities @@ -16856,8 +31548,10 @@ muncipality,municipality mundance,mundane mundande,mundane muniches,munchies +municiple,municipal munipulative,manipulative munnicipality,municipality +munute,minute murderd,murdered murdererd,murdered murderered,murdered @@ -16865,6 +31559,7 @@ murdereres,murderers murdererous,murderers murderes,murders murderus,murders +muscels,mussels,muscles muscial,musical muscially,musically muscician,musician @@ -16881,35 +31576,75 @@ musicallity,musically musicaly,musically musilms,muslims muslces,muscles +mustator,mutator +muste,must musuclar,muscular musuems,museums +mutablity,mutability mutatin,mutation mutatiohn,mutation +mutbale,mutable +mutch,much +mutches,matches +mutecies,mutexes +mutexs,mutexes +muti,multi mutialted,mutilated mutialtion,mutilation +muticast,multicast +mutices,mutexes +mutiindex,multiindex mutilatin,mutilation +mutilcast,multicast mutiliated,mutilated +mutimarked,multimarked +mutipath,multipath +mutipl,multiple,multiply +mutiple,multiple +mutiply,multiply +mutli,multi mutliated,mutilated mutliation,mutilation mutlinational,multinational mutlinationals,multinational +mutlipart,multipart mutliplayer,multiplayer mutliple,multiple +mutlipler,multiplier,multiple mutliples,multiples mutliplication,multiplication +mutliplicites,multiplicities mutliplied,multiplied mutliplier,multiplier +mutlipliers,multipliers mutliply,multiply mutliplying,multiplying mutlitasking,multitasking mutlitude,multitude mutliverse,multiverse +mutully,mutually +mutux,mutex +mutuxes,mutexes +mutuxs,mutexes +muyst,must +myabe,maybe +mybe,maybe +mye,may,my myhtical,mythical +myitereator,myiterator mypsace,myspace myraid,myriad mysapce,myspace mysef,myself +mysefl,myself +mysekf,myself +myselfe,myself +myselfes,myself +myselv,myself +myselve,myself +myselves,myself mysitcal,mystical +myslef,myself mysoganistic,misogynistic mysogenistic,misogynistic mysogonistic,misogynistic @@ -16924,16 +31659,42 @@ mysteriousy,mysteriously mysteris,mysteries mysterise,mysteries mysterous,mysterious +mystql,mysql mythraic,mithraic +myu,my nacionalistic,nationalistic nacionalists,nationalists nacrotics,narcotics +nadly,badly +naerly,nearly,gnarly naferious,nefarious +nagative,negative +nagatively,negatively +nagatives,negatives nagivate,navigate nagivating,navigating nagivation,navigation nahsville,nashville naieve,naive +namd,named,name +namemespace,namespace +namepace,namespace +namepsace,namespace +namepsaces,namespaces +namesd,named,names +namesspaces,namespaces +namme,name +namne,name +namned,named +namnes,names +namnespace,namespace +namnespaces,namespaces +nams,names +nane,name +nanosencond,nanosecond +nanosenconds,nanoseconds +nanoseond,nanosecond +nanoseonds,nanoseconds naopleon,napoleon napcakes,pancakes naploeon,napoleon @@ -16991,6 +31752,8 @@ narwharl,narwhal naseuous,nauseous nashvile,nashville nashvillle,nashville +nastly,nasty +nastyness,nastiness nasueous,nauseous nasvhille,nashville natievly,natively @@ -17051,6 +31814,7 @@ naturely,naturally naturens,natures naturual,natural naturually,naturally +natvigation,navigation nauesous,nauseous naughtly,naughty naugthy,naughty @@ -17060,9 +31824,13 @@ nauseuos,nauseous nautils,nautilus nautiuls,nautilus nautlius,nautilus -nautral,natural +nautral,natural,neutral nautres,natures nautulis,nautilus +navagate,navigate +navagating,navigating +navagation,navigation +navagitation,navigation naviagte,navigate naviagting,navigating naviagtion,navigation @@ -17070,29 +31838,60 @@ navigatie,navigate navigatin,navigation navigato,navigation navigatore,navigate +nax,max,nad +naxima,maxima +naximal,maximal +naximum,maximum nazereth,nazareth nazionalists,nationalists +nclude,include +nd,and +nead,need +neaded,needed,kneaded +neagtive,negative +nealy,nearly,newly +neares,nearest +nearset,nearest +neast,nearest,beast +necassery,necessary +necassry,necessary +necause,because +neccecarily,necessarily +neccecary,necessary neccesarily,necessarily neccesary,necessary neccessarily,necessarily +neccessarry,necessary neccessary,necessary neccessities,necessities +neccisary,necessary +neccsessary,necessary necesarily,necessarily +necesarrily,necessarily +necesarry,necessary necesary,necessary +necessaery,necessary necessairly,necessarily necessairy,necessarily +necessar,necessary necessarilly,necessarily +necessariy,necessary,necessarily necessarly,necessary necessarry,necessary +necessaryly,necessarily necessaties,necessities +necessay,necessary necesseraly,necessarily necesserily,necessarily +necessery,necessary +necessesary,necessary necessiate,necessitate necessiates,necessities necessite,necessities necessites,necessities necessitites,necessities necessitive,necessities +nechanism,mechanism neckbead,neckbeard neckbearders,neckbeards neckbeardese,neckbeards @@ -17114,25 +31913,64 @@ necromamcer,necromancer necromaner,necromancer necromanser,necromancer necromencer,necromancer +necssary,necessary nectode,netcode +ned,need +nedd,need +nedded,needed +neded,needed +nedia,media +nedium,medium +nediums,mediums +nedle,needle +nedles,needles,needless +nedless,needless,needles nedlessly,endlessly +neede,needed,need +needeed,needed needels,needles needlees,needles needleslly,needlessly needlessley,needlessly needlessy,needlessly +neeed,need +neeeded,needed +neeeding,needing +neeedle,needle +neeedles,needles,needless +neeedless,needless,needles +neeeds,needs +nees,needs +neesd,needs +neesds,needs +neet,need,neat nefarios,nefarious +negaive,negative +negarive,negative +negatiotiable,negotiable +negatiotiate,negotiate +negatiotiated,negotiated +negatiotiates,negotiates +negatiotiating,negotiating +negatiotiation,negotiation +negatiotiations,negotiations +negatiotiator,negotiator +negatiotiators,negotiators +negativ,negative negativaty,negativity negativeity,negativity negativelly,negatively negativitiy,negativity negativley,negatively negativy,negativity +negatve,negative negelcting,neglecting +negible,negligible negilgence,negligence negiotate,negotiate negiotated,negotiated negiotating,negotiating +negitive,negative neglacting,neglecting neglagence,negligence neglectn,neglecting @@ -17146,22 +31984,125 @@ neglicible,negligible neglicting,neglecting negligable,negligible negligance,negligence +negligble,negligible negligeble,negligible negligente,negligence negligiable,negligible +negoable,negotiable +negoate,negotiate +negoated,negotiated +negoates,negotiates +negoatiable,negotiable +negoatiate,negotiate +negoatiated,negotiated +negoatiates,negotiates +negoatiating,negotiating +negoatiation,negotiation +negoatiations,negotiations +negoatiator,negotiator +negoatiators,negotiators +negoating,negotiating +negoation,negotiation +negoations,negotiations +negoator,negotiator +negoators,negotiators +negociable,negotiable negociate,negotiate negociated,negotiated +negociates,negotiates negociating,negotiating negociation,negotiation negociations,negotiations +negociator,negotiator +negociators,negotiators negogiated,negotiated +negogtiable,negotiable +negogtiate,negotiate +negogtiated,negotiated +negogtiates,negotiates +negogtiating,negotiating +negogtiation,negotiation +negogtiations,negotiations +negogtiator,negotiator +negogtiators,negotiators +negoitable,negotiable negoitate,negotiate negoitated,negotiated +negoitates,negotiates negoitating,negotiating negoitation,negotiation negoitations,negotiations +negoitator,negotiator +negoitators,negotiators +negoptionsotiable,negotiable +negoptionsotiate,negotiate +negoptionsotiated,negotiated +negoptionsotiates,negotiates +negoptionsotiating,negotiating +negoptionsotiation,negotiation +negoptionsotiations,negotiations +negoptionsotiator,negotiator +negoptionsotiators,negotiators +negosiable,negotiable +negosiate,negotiate +negosiated,negotiated +negosiates,negotiates +negosiating,negotiating +negosiation,negotiation +negosiations,negotiations +negosiator,negotiator +negosiators,negotiators +negotable,negotiable +negotaiable,negotiable +negotaiate,negotiate +negotaiated,negotiated +negotaiates,negotiates +negotaiating,negotiating +negotaiation,negotiation +negotaiations,negotiations +negotaiator,negotiator +negotaiators,negotiators +negotaible,negotiable +negotaite,negotiate negotaited,negotiated +negotaites,negotiates +negotaiting,negotiating +negotaition,negotiation +negotaitions,negotiations +negotaitor,negotiator +negotaitors,negotiators +negotate,negotiate +negotated,negotiated +negotates,negotiates +negotatiable,negotiable +negotatiate,negotiate +negotatiated,negotiated +negotatiates,negotiates +negotatiating,negotiating +negotatiation,negotiation +negotatiations,negotiations +negotatiator,negotiator +negotatiators,negotiators +negotatible,negotiable +negotatie,negotiate +negotatied,negotiated +negotaties,negotiates +negotating,negotiating negotation,negotiation +negotations,negotiations +negotatior,negotiator +negotatiors,negotiators +negotator,negotiator +negotators,negotiators +negothiable,negotiable +negothiate,negotiate +negothiated,negotiated +negothiates,negotiates +negothiating,negotiating +negothiation,negotiation +negothiations,negotiations +negothiator,negotiator +negothiators,negotiators negotiaion,negotiation negotiatians,negotiations negotiatie,negotiated @@ -17173,60 +32114,351 @@ negotiatiors,negotiations negotiative,negotiate negotiaton,negotiation negotiatons,negotiations -neice,niece +negotible,negotiable +negoticable,negotiable +negoticate,negotiate +negoticated,negotiated +negoticates,negotiates +negoticating,negotiating +negotication,negotiation +negotications,negotiations +negoticator,negotiator +negoticators,negotiators +negotinate,negotiate +negotioable,negotiable +negotioate,negotiate +negotioated,negotiated +negotioates,negotiates +negotioating,negotiating +negotioation,negotiation +negotioations,negotiations +negotioator,negotiator +negotioators,negotiators +negotioble,negotiable +negotion,negotiation +negotionable,negotiable +negotionate,negotiate +negotionated,negotiated +negotionates,negotiates +negotionating,negotiating +negotionation,negotiation +negotionations,negotiations +negotionator,negotiator +negotionators,negotiators +negotions,negotiations +negotiotable,negotiable +negotiotate,negotiate +negotiotated,negotiated +negotiotates,negotiates +negotiotating,negotiating +negotiotation,negotiation +negotiotations,negotiations +negotiotator,negotiator +negotiotators,negotiators +negotiote,negotiate +negotioted,negotiated +negotiotes,negotiates +negotioting,negotiating +negotiotion,negotiation +negotiotions,negotiations +negotiotor,negotiator +negotiotors,negotiators +negotitable,negotiable +negotitae,negotiate +negotitaed,negotiated +negotitaes,negotiates +negotitaing,negotiating +negotitaion,negotiation +negotitaions,negotiations +negotitaor,negotiator +negotitaors,negotiators +negotitate,negotiate +negotitated,negotiated +negotitates,negotiates +negotitating,negotiating +negotitation,negotiation +negotitations,negotiations +negotitator,negotiator +negotitators,negotiators +negotite,negotiate +negotited,negotiated +negotites,negotiates +negotiting,negotiating +negotition,negotiation +negotitions,negotiations +negotitor,negotiator +negotitors,negotiators +negoziable,negotiable +negoziate,negotiate +negoziated,negotiated +negoziates,negotiates +negoziating,negotiating +negoziation,negotiation +negoziations,negotiations +negoziator,negotiator +negoziators,negotiators +negtive,negative +neice,niece,nice neigbhorhood,neighborhoods neigbhour,neighbour neigbhourhood,neighbourhood neigbhours,neighbours +neigbor,neighbor neigborhood,neighborhood -neigbour,neighbour +neigboring,neighboring +neigbors,neighbors +neigbour,neighbour,neighbour neigbourhood,neighbourhood -neigbouring,neighbouring -neigbours,neighbours +neigbouring,neighbouring,neighbouring +neigbours,neighbours,neighbours +neighbar,neighbor +neighbarhood,neighborhood +neighbarhoods,neighborhoods +neighbaring,neighboring +neighbars,neighbors +neighbbor,neighbor +neighbborhood,neighborhood +neighbborhoods,neighborhoods +neighbboring,neighboring +neighbbors,neighbors +neighbeard,neighborhood +neighbeards,neighborhoods +neighbehood,neighborhood +neighbehoods,neighborhoods +neighbeing,neighboring +neighbeod,neighborhood +neighbeods,neighborhoods +neighbeor,neighbor +neighbeordhood,neighborhood +neighbeordhoods,neighborhoods +neighbeorhod,neighborhood +neighbeorhods,neighborhoods +neighbeorhood,neighborhood +neighbeorhoods,neighborhoods +neighbeors,neighbors +neighber,neighbor +neighbergh,neighbor +neighberghs,neighbors +neighberhhod,neighborhood +neighberhhods,neighborhoods +neighberhhood,neighborhood +neighberhhoods,neighborhoods +neighberhing,neighboring +neighberhod,neighborhood +neighberhodd,neighborhood +neighberhodds,neighborhoods +neighberhods,neighborhoods +neighberhood,neighborhood +neighberhooding,neighboring +neighberhoods,neighborhoods +neighberhoof,neighborhood +neighberhoofs,neighborhoods +neighberhoood,neighborhood +neighberhooods,neighborhoods +neighberhoor,neighbor +neighberhoors,neighbors +neighberhoud,neighborhood +neighberhouds,neighborhoods +neighbering,neighboring +neighbers,neighbors +neighbes,neighbors +neighbet,neighbor +neighbethood,neighborhood +neighbethoods,neighborhoods +neighbets,neighbors +neighbeuing,neighbouring +neighbeurgh,neighbour +neighbeurghs,neighbours +neighbeurhing,neighbouring +neighbeurhooding,neighbouring +neighbeurhoor,neighbour +neighbeurhoors,neighbours +neighbeus,neighbours +neighbeut,neighbour +neighbeuthood,neighbourhood +neighbeuthoods,neighbourhoods +neighbeuts,neighbours +neighbhor,neighbor +neighbhorhood,neighborhood +neighbhorhoods,neighborhoods +neighbhoring,neighboring neighbhors,neighbors -neighboor,neighbor -neighboorhod,neighbourhood +neighboard,neighborhood +neighboards,neighborhoods +neighbohood,neighborhood +neighbohoods,neighborhoods +neighboing,neighboring +neighbood,neighborhood +neighboods,neighborhoods +neighboor,neighbor,neighbour +neighboordhood,neighborhood +neighboordhoods,neighborhoods +neighboorhod,neighbourhood,neighborhood +neighboorhods,neighborhoods +neighboorhood,neighborhood +neighboorhoods,neighborhoods neighboorhoud,neighbourhood +neighbooring,neighboring +neighboors,neighbors,neighbours neighbords,neighbors neighborehood,neighborhood neighbores,neighbors +neighborgh,neighbor +neighborghs,neighbors +neighborhhod,neighborhood +neighborhhods,neighborhoods +neighborhhood,neighborhood +neighborhhoods,neighborhoods neighborhing,neighboring neighborhod,neighborhood +neighborhodd,neighborhood +neighborhodds,neighborhoods neighborhods,neighborhoods -neighborhoood,neighborhoods +neighborhooding,neighboring +neighborhoof,neighborhood +neighborhoofs,neighborhoods +neighborhoood,neighborhoods,neighborhood +neighborhooods,neighborhoods +neighborhoor,neighbor +neighborhoors,neighbors +neighborhoud,neighborhood +neighborhouds,neighborhoods +neighbos,neighbors +neighbot,neighbor +neighbothood,neighborhood +neighbothoods,neighborhoods +neighbots,neighbors +neighbouing,neighbouring neighbourbood,neighbourhood +neighbourgh,neighbour neighbourghs,neighbours neighbourgood,neighbourhood neighbourgs,neighbours +neighbourhhod,neighbourhood +neighbourhhods,neighbourhoods +neighbourhhood,neighbourhood +neighbourhhoods,neighbourhoods +neighbourhing,neighbouring neighbourhod,neighbourhood +neighbourhodd,neighbourhood +neighbourhodds,neighbourhoods +neighbourhods,neighbourhoods +neighbourhooding,neighbouring +neighbourhoof,neighbourhood +neighbourhoofs,neighbourhoods neighbourhoood,neighbourhood +neighbourhooods,neighbourhoods +neighbourhoor,neighbour +neighbourhoors,neighbours neighbourhoud,neighbourhood +neighbourhouds,neighbourhoods neighbourood,neighbourhood +neighbous,neighbours +neighbout,neighbour +neighbouthood,neighbourhood +neighbouthoods,neighbourhoods +neighbouts,neighbours +neighbr,neighbor neighbrohood,neighborhoods +neighbrs,neighbors +neighbur,neighbor +neighburhood,neighborhood +neighburhoods,neighborhoods +neighburing,neighboring +neighburs,neighbors +neigher,neither +neighobr,neighbor +neighobrhood,neighborhood +neighobrhoods,neighborhoods +neighobring,neighboring +neighobrs,neighbors +neighor,neighbor +neighorhood,neighborhood +neighorhoods,neighborhoods +neighoring,neighboring +neighors,neighbors +neighour,neighbour neighourhood,neighbourhood neighourhoods,neighbourhoods neighouring,neighbouring +neighours,neighbours +neighror,neighbor +neighrorhood,neighborhood +neighrorhoods,neighborhoods +neighroring,neighboring +neighrors,neighbors +neighrour,neighbour +neighrourhood,neighbourhood +neighrourhoods,neighbourhoods +neighrouring,neighbouring +neighrours,neighbours +neight,neither +neightbor,neighbor +neightborhood,neighborhood +neightborhoods,neighborhoods +neightboring,neighboring +neightbors,neighbors +neightbour,neighbour +neightbourhood,neighbourhood +neightbourhoods,neighbourhoods +neightbouring,neighbouring +neightbours,neighbours +neighter,neither +neightobr,neighbor +neightobrhood,neighborhood +neightobrhoods,neighborhoods +neightobring,neighboring +neightobrs,neighbors +neiter,neither +nelink,netlink +nenviroment,environment neolitic,neolithic neoroscience,neuroscience nercomancer,necromancer neruological,neurological neruons,neurons neruoscience,neuroscience +nerver,never +nescessarily,necessarily +nescessary,necessary +nesesarily,necessarily neslave,enslave +nessary,necessary nessasarily,necessarily +nessasary,necessary +nessecarilt,necessarily +nessecarily,necessarily +nessecarry,necessary nessecary,necessary +nesseccary,necessary +nessesarily,necessarily +nessesary,necessary +nessessarily,necessarily +nessessary,necessary nestin,nesting +nestwork,network +netacpe,netscape netboook,netbook +netcape,netscape +nethods,methods +netiher,neither netocde,netcode netowrk,network netowrking,networking +netowrks,networks netropolitan,metropolitan netruality,neutrality -netural,neutral +netscpe,netscape +netural,neutral,natural neturality,neutrality neturon,neutron +netwplit,netsplit netwrok,network +netwroked,networked netwroking,networking +netwroks,networks +netwrork,network +neumeric,numeric neuorscience,neuroscience neuralogical,neurological neuroligical,neurological @@ -17244,7 +32476,10 @@ neutrailty,neutrality neutrallity,neutrality neutralt,neutrality neutraly,neutrality +nevere,never +neveretheless,nevertheless neverhteless,nevertheless +nevers,never neverthelss,nevertheless neverthless,nevertheless newcaslte,newcastle @@ -17252,10 +32487,15 @@ newcaste,newcastle newcastel,newcastle newletters,newsletters newlsetter,newsletter +nework,network +neworks,networks newsettler,newsletter newslatter,newsletter +newslines,newlines newspapaers,newspapers newspappers,newspapers +newthon,newton +newtork,network nickanme,nickname nickmane,nickname nieghbor,neighbor @@ -17266,6 +32506,9 @@ nieghbour,neighbour nieghbourhood,neighbourhood nieghbourhoods,neighbourhood nieghbours,neighbours +nighbor,neighbor +nighborhood,neighborhood +nighboring,neighboring nighlty,nightly nightime,nighttime nightlcub,nightclub @@ -17284,24 +32527,44 @@ nihilim,nihilism nihilisim,nihilism nihilsim,nihilism nilihism,nihilism +nimutes,minutes +nin,inn,min,bin,nine nineth,ninth +ninima,minima +ninimal,minimal +ninimum,minimum +ninjs,ninja ninteenth,nineteenth -ninties,1990s -ninty,ninety +ninties,nineties +ninty,ninety,minty nipticking,nitpicking nirtogen,nitrogen nirvanna,nirvana +nither,neither nitorgen,nitrogen nitpciking,nitpicking niusance,nuisance niverse,inverse +nknown,unknown nkow,know nkwo,know nmae,name +nned,need +nnumber,number noctrune,nocturne noctunre,nocturne nocture,nocturne nocturen,nocturne +nodel,model,nodal +nodels,models +nodess,nodes +nodulated,modulated +noe,not,no,node,know,now +nofified,notified +nofity,notify +nohypen,nohyphen +noice,noise,nice,notice +nomimal,nominal nominacion,nomination nominae,nominate nominatie,nominate @@ -17312,30 +32575,66 @@ nominato,nomination nominatons,nominations nominet,nominate noncombatents,noncombatants +nonexistance,nonexistence +nonexistant,nonexistent noninital,noninitial noninitalized,noninitialized +nonnegarive,nonnegative nonsence,nonsense nonsencial,nonsensical nonsencical,nonsensical nonsene,nonsense +nonsens,nonsense nonsenscial,nonsensical nonsensicle,nonsensical nonsesne,nonsense +nonte,note nontheless,nonetheless +noo,no +noral,normal,moral +noralize,normalize +noralized,normalized +noramal,normal +noramalise,normalise +noramalised,normalised +noramalises,normalises +noramalising,normalising +noramalize,normalize +noramalized,normalized +noramalizes,normalizes +noramalizing,normalizing +noramals,normals +noraml,normal noramlly,normally noramls,normals +nore,nor,more norhern,northern norhteast,northeast norhtern,northern norhtwest,northwest norhtwestern,northwestern +norifications,notifications +normailzation,normalization +normaized,normalized +normale,normal +normales,normals normalis,normals +normall,normal,normally normallized,normalized normalls,normals normalos,normals normaly,normally +normalyl,normally +normalyly,normally +normalysed,normalised +normalyy,normally +normalyzation,normalization +normalyze,normalize +normalyzed,normalized normanday,normandy normany,normandy +normlly,normally +normnal,normal northeat,northeast northen,northern northereastern,northeastern @@ -17345,6 +32644,7 @@ northren,northern northwesten,northwestern northwestener,northwestern northwet,northwest +nortmally,normally norwegain,norwegian norwegin,norwegian norwiegan,norwegian @@ -17365,7 +32665,11 @@ nostris,nostrils notabley,notably notablly,notably notacible,noticeable +notaion,notation +notaly,notably notario,ontario +notasion,notation +notatin,notation notciable,noticeable noteable,notable noteably,notably @@ -17375,8 +32679,15 @@ noteriety,notoriety noteworhty,noteworthy noteworthly,noteworthy noteworty,noteworthy +notfication,notification +notfications,notifications noth,north nothern,northern +nothign,nothing +nothigng,nothing +nothihg,nothing +nothin,nothing +nothind,nothing nothingess,nothingness nothingsness,nothingness noticabe,noticeable @@ -17385,36 +32696,66 @@ noticable,noticeable noticabley,noticeably noticably,noticeably noticalbe,noticeable +notication,notification +notications,notifications noticeablely,noticeably noticeabley,noticeably noticeing,noticing +noticiable,noticeable noticiably,noticeably noticible,noticeable +notidy,notify +notifaction,notification +notifactions,notifications +notifcation,notification +notifcations,notifications +notifed,notified +notifer,notifier +notifes,notifies notificacion,notification +notificaction,notification notificaiton,notification notificaitons,notifications notificaton,notification notificatons,notifications +notificiation,notification +notifiy,notify +notifiying,notifying +notifycation,notification +notity,notify +notmalize,normalize +notmalized,normalized +notmutch,notmuch +notning,nothing notorios,notorious notoriosly,notoriously notoriuosly,notoriously notoroius,notorious +notse,notes,note +nott,not notwhithstanding,notwithstanding noveau,nouveau novembeard,november +novemer,november novermber,november novmeber,november +nowadys,nowadays nowdays,nowadays nowe,now nrivana,nirvana nromandy,normandy +ntification,notification nto,not nuaghty,naughty nuatilus,nautilus +nuber,number +nubering,numbering +nubmer,number nubmers,numbers nucelar,nuclear nucelus,nucleus nuclean,unclean +nucleous,nucleus,nucleolus nuclues,nucleus nucular,nuclear nuculear,nuclear @@ -17426,14 +32767,47 @@ nuetral,neutral nuetrality,neutrality nuetron,neutron nuisanse,nuisance +nuissance,nuisance nulcear,nuclear +nulk,null nullabour,nullarbor nullfiy,nullify nullifiy,nullify +nulll,null +numberal,numeral +numberals,numerals +numberic,numeric numberous,numerous +numbert,number +numbres,numbers +numearate,numerate +numearation,numeration +numeber,number +numebering,numbering +numebers,numbers +numebr,number +numebrs,numbers +numer,number +numeraotr,numerator +numerbering,numbering numercial,numerical +numerial,numeral,numerical numericable,numerical +numering,numbering numerious,numerous +numers,numbers +nummber,number +nummbers,numbers +numnber,number +numnbered,numbered +numnbering,numbering +numnbers,numbers +numner,number +numners,numbers +numver,number +numvers,numbers +nunber,number +nunbers,numbers nuremburg,nuremberg nurtient,nutrient nurtients,nutrients @@ -17461,28 +32835,49 @@ nutrituous,nutritious nutrutional,nutritional nutrutious,nutritious nuturing,nurturing +nwe,new +nwo,now oarcles,oracles obamination,abomination obatinable,obtainable +obay,obey obdisian,obsidian +obect,object obediance,obedience obediant,obedient obeidence,obedience +obejct,object obejctives,objectives obersvant,observant obersvation,observation obersvations,observations obersvers,observers +obeserve,observe obession,obsession +obessions,obsessions obesssion,obsession +obgect,object +obgects,objects +obhect,object +obhectification,objectification +obhectifies,objectifies +obhectify,objectify +obhectifying,objectifying +obhecting,objecting +obhection,objection +obhects,objects obiedence,obedience obilgatory,obligatory obilterated,obliterated obilvion,oblivion +obious,obvious +obiously,obviously obisdian,obsidian obivous,obvious obivously,obviously +objec,object objecitves,objectives +objecs,objects objectificaiton,objectification objectificaton,objectification objectificiation,objectification @@ -17500,7 +32895,18 @@ objectivs,objectives objectivst,objectives objectivty,objectivity objectivy,objectivity +objectss,objects +objejct,object +objekt,object objektives,objectives +objet,object +objetc,object +objetcs,objects +objets,objects +objtain,obtain +objtained,obtained +objtains,obtains +objump,objdump obliberated,obliterated obliderated,obliterated obligerated,obliterated @@ -17511,9 +32917,14 @@ obliteraded,obliterated obliterared,obliterated oblitirated,obliterated oblitorated,obliterated +oblitque,oblique obliverated,obliterated +obnject,object obscruity,obscurity obscuirty,obscurity +obscur,obscure +obselete,obsolete +observ,observe observabil,observable observacion,observation observaiton,observant @@ -17531,7 +32942,15 @@ observible,observable obsessie,obsessive obsessin,obsession obsessivley,obsessive +obsevrer,observer +obsevrers,observers obsidain,obsidian +obsolate,obsolete +obsolesence,obsolescence +obsolite,obsolete +obsolited,obsoleted +obsolte,obsolete +obsolted,obsoleted obssesion,obsession obssesive,obsessive obssessed,obsessed @@ -17544,19 +32963,35 @@ obstructin,obstruction obstruktion,obstruction obsturction,obstruction obsucrity,obscurity +obsure,obscure +obtaien,obtain,obtained +obtaiend,obtained +obtaiens,obtains obtainabe,obtainable obtainabie,obtainable obtaineble,obtainable obtainible,obtainable +obtaion,obtain +obtaioned,obtained +obtaions,obtains obtianable,obtainable +obtrain,obtain +obtrained,obtained +obtrains,obtains +obusing,abusing obversation,observation obversations,observations obvilion,oblivion obviosuly,obviously obvioulsy,obviously +obvisious,obvious obvisouly,obviously +obvisous,obvious +obvisously,obviously obvoius,obvious obvoiusly,obviously +obyect,object +obyekt,object ocarnia,ocarina ocasion,occasion ocasional,occasional @@ -17574,6 +33009,8 @@ occaison,occasion occaisonal,occasional occaisonally,occasionally occaisons,occasions +occasinal,occasional +occasinally,occasionally occasioanlly,occasionally occasionals,occasions occasionaly,occasionally @@ -17587,23 +33024,44 @@ occassioned,occasioned occassions,occasions occational,occasional occationally,occasionally +occcur,occur +occcured,occurred +occcurs,occurs occour,occur +occoured,occurred +occouring,occurring +occourring,occurring +occours,occurs +occsionally,occasionally occulation,occupation occupaiton,occupation occupato,occupation +occuped,occupied +occupided,occupied +occuracy,accuracy occurance,occurrence occurances,occurrences +occurately,accurately +occurd,occurred,occur +occurded,occurred +occure,occur,occurred occured,occurred occurence,occurrence occurences,occurrences +occures,occurs occuring,occurring occurr,occur occurrance,occurrence occurrances,occurrences occurrencies,occurrences +occurrs,occurs +ocntext,context +ocorrence,occurrence +ocorrences,occurrences ocotber,october ocotpus,octopus ocraina,ocarina +octect,octet octobear,october octohedra,octahedra octohedral,octahedral @@ -17611,49 +33069,111 @@ octohedron,octahedron octopuns,octopus ocuntries,countries ocuntry,country +ocupied,occupied +ocupies,occupies +ocupy,occupy +ocupying,occupying +ocur,occur ocurr,occur ocurrance,occurrence ocurred,occurred ocurrence,occurrence +ocurrences,occurrences +oder,order,odor +odly,oddly +oen,one +oerflow,overflow ofcoruse,ofcourse ofcoure,ofcourse ofcoures,ofcourse ofcousre,ofcourse ofcrouse,ofcourse offcers,officers +offcial,official offcially,officially +offcials,officials offensivelly,offensively offensivley,offensively offensivly,offensively +offerd,offered offereings,offerings offesnively,offensively +offest,offset +offests,offsets +offet,offset,offer +offets,offsets,offers +offic,office officailly,officially offical,official offically,officially officals,officials officaly,officially +officeal,official +officeally,officially +officeals,officials +officealy,officially officiallly,officially officialy,officially offisde,offside +offloded,offloaded offpsring,offspring offred,offered +offser,offset +offseted,offsetted +offseting,offsetting +offsetp,offset +offsett,offset offsited,offside offspirng,offspring offsrping,offspring +offstets,offsets +offten,often +oficial,official +oficially,officially +ofo,of ofocurse,ofcourse +ofrom,from +ofsetted,offsetted oftenly,often -oging,going +ofthen,often +oging,going,ogling ogliarchy,oligarchy ogranisation,organisation ogrilla,gorilla +oherwise,otherwise +ohter,other +ohters,others +ohterwise,otherwise +oigin,origin +oiginal,original +oiginally,originally +oiginals,originals +oiginating,originating +oigins,origins oilgarchy,oligarchy +oints,points,pints +ois,is +ojbect,object +oje,one +oject,object +ojection,objection +ojective,objective +ojects,objects +ojekts,objects +okat,okay olbigatory,obligatory olbiterated,obliterated +oldes,oldest oligarcy,oligarchy oligrachy,oligarchy +oll,all,ole,old,olly,oil olmypic,olympic olmypics,olympics +olny,only olreans,orleans +olt,old +olther,other +oly,only olymipcs,olympics olympis,olympics olypmic,olympic @@ -17663,10 +33183,14 @@ ominscient,omniscient omision,omission omited,omitted omiting,omitting +omitt,omit omlette,omelette ommision,omission +ommission,omission +ommit,omit ommited,omitted ommiting,omitting +ommits,omits ommitted,omitted ommitting,omitting omnipetent,omnipotent @@ -17677,53 +33201,194 @@ omnisicent,omniscient omniverous,omnivorous omniverously,omnivorously omnsicient,omniscient +omplementaion,implementation +omplementation,implementation omre,more onatrio,ontario onbaord,onboard onborad,onboard +onces,ounces,once,ones +ond,one +onece,once +oneyway,oneway ongewild,gonewild +ongly,only +onl,only +onlie,online,only +onliene,online +onlly,only onlsaught,onslaught onmipotent,omnipotent onmiscient,omniscient -onot,note +onoly,only +onot,note,not +ons,owns onsalught,onslaught +onself,oneself +onservation,conservation,observation onslaugt,onslaught onslaugth,onslaught onsluaght,onslaught +ontain,contain +ontained,contained +ontainer,container +ontainers,containers +ontainging,containing +ontaining,containing +ontainor,container +ontainors,containers +ontains,contains ontairo,ontario ontraio,ontario +ontrolled,controlled onwership,ownership +ony,only onyl,only +oommits,commits +opactity,opacity +opacy,opacity +opague,opaque opartor,operator +opatque,opaque +opbject,object +opbjective,objective +opbjects,objects +opeaaration,operation +opeaarations,operations +opeabcration,operation +opeabcrations,operations +opearand,operand +opearands,operands +opearate,operate +opearates,operates +opearating,operating +opearation,operation +opearations,operations +opearatios,operations +opearator,operator +opearators,operators +opearion,operation +opearions,operations +opearios,operations +opeariton,operation +opearitons,operations +opearitos,operations +opearnd,operand +opearnds,operands +opearor,operator +opearors,operators +opearte,operate +opearted,operated +opeartes,operates +opearting,operating +opeartion,operation +opeartions,operations +opeartios,operations +opeartor,operator +opeartors,operators +opeate,operate +opeates,operates +opeation,operation +opeational,operational +opeations,operations +opeatios,operations +opeator,operator +opeators,operators +opeatror,operator +opeatrors,operators +opeg,open +opeging,opening +opeing,opening +opeinging,opening +opeings,openings +opem,open +opemed,opened +opemess,openness +opeming,opening +opems,opens +openbrower,openbrowser +openeing,opening +openend,opened +openened,opened +openening,opening openess,openness +openin,opening +openned,opened +openning,opening +openscource,opensource +openscourced,opensourced +operaand,operand +operaands,operands operacional,operational +operaion,operation +operaiton,operation +operandes,operands +operaror,operator operasional,operational +operatation,operation +operatations,operations +operater,operator operatie,operative operatings,operations +operatio,operation operationable,operational +operatione,operation operationel,operational operationnal,operational +operatior,operator operativne,operative operativos,operations +operatng,operating +operaton,operation +operatons,operations +operattion,operation +operattions,operations +opereation,operation +opertaion,operation +opertaions,operations +opertion,operation +opertional,operational +opertions,operations +opetional,optional +ophan,orphan opiniones,opinions opinoins,opinions +opion,option +opionally,optionally +opions,options opitcal,optical opitmal,optimal +opiton,option +opitons,options +opne,open +opnegroup,opengroup +opnssl,openssl oponent,opponent +oportions,options,apportions oportunity,opportunity opose,oppose +oposed,opposed oposite,opposite oposition,opposition oppenly,openly +opperation,operation +opperational,operational +opperations,operations +oppertunist,opportunist oppertunities,opportunities +oppertunity,opportunity oppinion,opinion +oppinions,opinions opponant,opponent opponenet,opponent opponenets,opponent opponet,opponent oppononent,opponent opportuniste,opportunities +opportunisticly,opportunistically +opportunistly,opportunistically opportunites,opportunities +opportunties,opportunities opposiste,opposites oppositition,opposition opposits,opposites @@ -17736,31 +33401,89 @@ oppresssing,oppressing oppresssion,oppression opprotunities,opportunities opprotunity,opportunity +opproximate,approximate +opps,oops +oppsofite,opposite oppurtunities,opportunities +oppurtunity,opportunity +opration,operation +opreating,operating +opreation,operation +opreations,operations opression,oppression opressive,oppressive oprhans,orphans +optain,obtain +optained,obtained +optains,obtains +optaionl,optional +opten,often,open +optening,opening +optet,opted opthalmic,ophthalmic opthalmologist,ophthalmologist opthalmology,ophthalmology opthamologist,ophthalmologist +optiional,optional optimaal,optimal +optimasation,optimisation +optimation,optimization,optimisation +optimazation,optimization +optimiality,optimality +optimier,optimizer,optimiser optimim,optimism optimisim,optimism optimisitc,optimistic optimisitic,optimistic +optimissm,optimism optimistc,optimistic optimistisch,optimistic +optimitation,optimization optimizacion,optimization +optimizaing,optimizing optimizare,optimize optimizate,optimize optimizating,optimization optimizaton,optimization optimizied,optimize +optimizier,optimizer +optimyze,optimize +optimze,optimize optimziation,optimization -optinally,optimally +optimzie,optimize +optin,option +optinal,optional +optinally,optimally,optionally +optio,option +optioanl,optional +optioin,option +optioinal,optional +optioins,options +optionall,optional,optionally +optionalliy,optionally +optionallly,optionally +optionaly,optionally +optionel,optional +optiones,options +optionial,optional +optionn,option +optionnal,optional +optionnaly,optionally +optionss,options +optios,options +optismied,optimised +optizmied,optimized +optmisation,optimisation +optmisations,optimisations +optmization,optimization optmizations,optimizations +optmize,optimize +optmized,optimized +optoin,option +optoins,options optomism,optimism +opulate,populate,opiate,opulent +opulates,populates,opiates oracels,oracles oragnered,orangered oragnes,oranges @@ -17774,6 +33497,7 @@ orangerd,orangered orangers,oranges orangism,organism orbtial,orbital +orcale,oracle orcales,oracles orcehstra,orchestra orchastrated,orchestrated @@ -17784,8 +33508,10 @@ orchestraed,orchestrated orchestrial,orchestra orchistrated,orchestrated orded,ordered +orderd,ordered ordianry,ordinary ordinarly,ordinary +ordner,order oreintal,oriental oreintation,orientation orelans,orleans @@ -17795,6 +33521,7 @@ orgainsed,organised orgainzation,organizations orgainze,organize orgainzer,organizer +orgamise,organise organered,orangered organes,organise organicaly,organically @@ -17803,6 +33530,8 @@ organiclly,organically organie,organise organim,organism organims,organism +organisaion,organisation +organisaions,organisations organisaiton,organisation organisate,organise organisationens,organisations @@ -17829,11 +33558,14 @@ organistaions,organisations organiste,organise organisten,organise organistion,organisation +organistions,organisations organiszed,organise organites,organise organizacion,organization organizacional,organizational organizaed,organize +organizaion,organization +organizaions,organizations organizaiton,organization organizaitonal,organizational organizare,organizer @@ -17849,6 +33581,7 @@ organizatons,organizations organizms,organism organizors,organizers organiztion,organization +organiztions,organizations organizuje,organize organsiation,organisation organsiations,organisations @@ -17865,57 +33598,147 @@ organziers,organizers orgasmes,orgasms orgasmos,orgasms orgasmus,orgasms -orgin,origin +orgiginal,original +orgiginally,originally +orgiginals,originals +orgin,origin,organ orginal,original orginally,originally +orginals,originals orginasation,organisation orginasations,organisations +orginate,originate +orginated,originated +orginates,originates +orginating,originating orginazation,organization orginazational,organizational orginazations,organizations -orginize,organize +orginial,original +orginially,originally +orginials,originals +orginiate,originate +orginiated,originated +orginiates,originates +orgininal,original +orgininals,originals +orginisation,organisation +orginisations,organisations +orginised,organised +orginization,organization +orginizations,organizations +orginize,organize,organize +orginized,organized +orgins,origins,organs +orginx,originx +orginy,originy orgnaisation,organisations orgnaised,organised orhcestra,orchestra +orhpan,orphan orhpans,orphans orhtodox,orthodox +oriant,orient +oriantate,orientate +oriantated,orientated +oriantation,orientation oribtal,orbital +oridinal,ordinal,original oridinarily,ordinarily oridnary,ordinary +orienatate,orientate +orienatated,orientated +orienatation,orientation +orienate,orientate,orient,ornate +orienation,orientation orientacion,orientation orientaion,orientation orientarla,oriental orientarlo,oriental +orientatied,orientated orientato,orientation +oriente,oriented +orientiation,orientation +orientied,oriented +orientned,oriented origanaly,originally +origial,original +origially,originally +origianal,original +origianally,originally +origianaly,originally +origianl,original origianlly,originally +origianls,originals +origigin,origin +origiginal,original +origiginally,originally +origiginals,originals originales,originals originalet,originated originalis,originals -originall,original +originall,original,originally originallity,originality originalt,originality originalty,originality originaly,originally originas,origins origines,origins +originial,original originially,originally +originiated,originated +originiating,originating +origininal,original +origininate,originate +origininated,originated +origininates,originates +origininating,originating +origining,originating originnally,originally originsl,originals origintea,originate +origion,origin origional,original +origionally,originally +orign,origin +orignal,original orignally,originally +orignial,original origniality,originality orignially,originally orignials,originals origniated,originated +origninal,original origonally,originally origonated,originated +oringal,original +oringally,originally orlenas,orleans orpahns,orphans +orpan,orphan +orpanage,orphanage +orpaned,orphaned +orpans,orphans orphanes,orphans +orriginal,original +orthagnal,orthogonal +orthagonal,orthogonal +orthagonalize,orthogonalize orthodx,orthodox +orthoganal,orthogonal +orthoganalize,orthogonalize +orthognal,orthogonal osbidian,obsidian +osbscure,obscure +osciallator,oscillator +oscilate,oscillate +oscilated,oscillated +oscilating,oscillating +oscilator,oscillator +osffset,offset +osffsets,offsets +osffsetting,offsetting +osicllations,oscillations ostencibly,ostensibly ostenisbly,ostensibly ostensably,ostensibly @@ -17929,32 +33752,120 @@ ostrazised,ostracised ostrecized,ostracized ostricized,ostracized ostrocized,ostracized +ot,to,of,or +otain,obtain +otained,obtained +otains,obtains otehr,other +otehrwice,otherwise +otehrwise,otherwise +otehrwize,otherwise +oter,other,otter +oterwice,otherwise +oterwise,otherwise +oterwize,otherwise +othe,other +othere,other +otherewise,otherwise +otherise,otherwise +otheriwse,otherwise +otherwaise,otherwise +otherways,otherwise +otherweis,otherwise +otherweise,otherwise +otherwhere,elsewhere +otherwhile,otherwise +otherwhise,otherwise +otherwice,otherwise +otherwide,otherwise +otherwis,otherwise +otherwize,otherwise +otherwordly,otherworldly +otherwose,otherwise +otherwrite,overwrite +otherws,otherwise +otherwse,otherwise +otherwsie,otherwise +otherwsise,otherwise +otherwuise,otherwise +otherwwise,otherwise +otherwyse,otherwise +othewice,otherwise +othewise,otherwise +othewize,otherwise +otho,otoh +othographic,orthographic othrodox,orthodox +othwerwise,otherwise +othwhise,otherwise +otification,notification +otiginal,original +otion,option +otional,optional,notional +otions,options +otpion,option +otpions,options +otput,output +otu,out oublisher,publisher ouevre,oeuvre +oultinenodes,outlinenodes +oultiner,outliner +oultline,outline +oultlines,outlines +ountline,outline +ouptut,output +ouptuted,outputted +ouptuting,outputting +ouptuts,outputs ouput,output +ouputarea,outputarea +ouputs,outputs +ouputted,outputted +ouputting,outputting +ourselfe,ourselves,ourself +ourselfes,ourselves +ourselfs,ourselves +ourselv,ourself,ourselves +ourselve,ourself,ourselves ourselvs,ourselves oursleves,ourselves +ouside,outside oustanding,outstanding +oustide,outside oustider,outsider oustiders,outsiders oustpoken,outspoken +outbut,output +outbuts,outputs outcalssed,outclassed outclasssed,outclassed outfeild,outfield outfidel,outfield outfied,outfield outfiled,outfield +outgoign,outgoing +outher,other,outer +outisde,outside outisder,outsider outisders,outsiders outlcassed,outclassed +outllook,outlook outnumbed,outnumbered outnumberd,outnumbered outnumbred,outnumbered outnunbered,outnumbered +outoign,outgoing +outout,output outpalyed,outplayed +outperfoem,outperform +outperfoeming,outperforming outperfom,outperform +outperfome,outperform +outperfomeing,outperforming +outperfoming,outperforming +outperfomr,outperform +outperfomring,outperforming outperfoms,outperform outperfrom,outperform outperfroms,outperform @@ -17962,7 +33873,12 @@ outplayd,outplayed outpreform,outperform outpreforms,outperform outpsoken,outspoken +outpupt,output +outpus,output,outputs +outpust,output,outputs +outpusts,outputs outputed,outputted +outputing,outputting outraegously,outrageously outrageos,outrageous outrageosly,outrageously @@ -17976,6 +33892,8 @@ outragious,outrageous outragiously,outrageously outragoues,outrageous outreagous,outrageous +outrside,outside +outselves,ourselves outsidr,outsider outskirst,outskirts outskirters,outskirts @@ -17988,8 +33906,24 @@ outsoure,outsourced outsouring,outsourcing outsoursed,outsourced outsoursing,outsourcing +outter,outer +outtermost,outermost +outupt,output +outupts,outputs +outuput,output +outut,output +oututs,outputs outweighes,outweighs +outweight,outweigh +outweights,outweighs outwieghs,outweighs +oveerun,overrun +oveflow,overflow +oveflowed,overflowed +oveflowing,overflowing +oveflows,overflows +ovelap,overlap +overaall,overall overarcing,overarching overbaord,overboard overbearring,overbearing @@ -18016,13 +33950,23 @@ overcloked,overclocked overcoding,overcoming overcomeing,overcoming overcomming,overcoming +overcompansate,overcompensate +overcompansated,overcompensated +overcompansates,overcompensates +overcompansating,overcompensating +overcompansation,overcompensation +overcompansations,overcompensations overdirve,overdrive overdrev,overdrive overeaching,overarching +overengeneer,overengineer +overengeneering,overengineering overestemating,overestimating overestimateing,overestimating overextimating,overestimating overfapping,overlapping +overfl,overflow +overfow,overflow overhal,overhaul overheading,overheating overheards,overhead @@ -18032,6 +33976,7 @@ overheathing,overheating overhooked,overlooked overhooking,overlooking overhpyed,overhyped +overhread,overhead overhtinking,overthinking overhual,overhaul overhwelm,overwhelm @@ -18039,26 +33984,41 @@ overhwelmed,overwhelmed overhwelming,overwhelming overhwelmingly,overwhelmingly overhwlemingly,overwhelmingly +overiddden,overridden +overidden,overridden +overide,override +overiden,overridden +overides,overrides +overiding,overriding overkapping,overlapping overklocked,overclocked overlanded,overloaded overlaod,overload overlaoded,overloaded +overlaped,overlapped overlaping,overlapping +overlapp,overlap overlappping,overlapping overlapsing,overlapping overlauded,overloaded +overlayed,overlaid overlcock,overclock overlcocked,overclocked overlcocking,overclocking overlcoking,overlooking +overlflow,overflow +overlfow,overflow overloard,overload overloards,overload +overlodaded,overloaded +overloded,overloaded +overlodes,overloads overlooming,overlooking overloooked,overlooked overlorded,overloaded overlordes,overlords overlordess,overlords +overlow,overflow overmapping,overlapping overnurfed,overturned overpad,overpaid @@ -18080,7 +34040,28 @@ overreactin,overreaction overreactiong,overreacting overreacton,overreaction overreaktion,overreaction +overreidden,overridden +overreide,override +overreides,overrides +overriabled,overridable +overriddable,overridable +overriddden,overridden +overridded,overrode,overridden +overridding,overriding +overrideable,overridable +overrided,overrode,overridden overriden,overridden +overrident,overridden +overridiing,overriding +overrie,override,ovary +overries,overrides,ovaries +overrite,overwrite,override,overrate +overrriddden,overridden +overrridden,overridden +overrride,override +overrriden,overridden +overrrides,overrides +overrriding,overriding oversemplification,oversimplification oversetimating,overestimating overshaddow,overshadowed @@ -18095,6 +34076,10 @@ oversimplificaton,oversimplification oversimplificiation,oversimplification oversimplifiction,oversimplification oversimplyfication,oversimplification +oversubscibe,oversubscribe +oversubscibed,oversubscribed +oversubscirbe,oversubscribe +oversubscirbed,oversubscribed oversue,overuse overtapping,overlapping overthining,overthinking @@ -18104,11 +34089,19 @@ overtunned,overturned overtunred,overturned overturing,overturn overules,overuse +overun,overrun +overvise,otherwise +overvize,otherwise overvlocked,overclocked +overvride,override +overvrides,overrides +overvrite,overwrite +overvrites,overwrites overwath,overwatch overwealmed,overwhelmed overwealming,overwhelming overweigth,overweight +overwelm,overwhelm overwelming,overwhelming overwhelemd,overwhelmed overwhelemed,overwhelmed @@ -18128,46 +34121,142 @@ overwhlemed,overwhelmed overwhleming,overwhelming overwhlemingly,overwhelmingly overwieght,overweight +overwiew,overview overwirte,overwrite +overwirting,overwriting +overwirtten,overwritten +overwise,otherwise +overwite,overwrite +overwites,overwrites +overwitten,overwritten +overwize,otherwise +overwridden,overridden,overwritten +overwride,overwrite +overwriteable,overwritable +overwriten,overwritten +overwritren,overwritten overwritte,overwrite overwritted,overwrite +overwrittes,overwrites +overwrittin,overwriting +overwritting,overwriting overwtach,overwatch overyhped,overhyped +ovride,override +ovrides,overrides +ovrlapped,overlapped +ovrridable,overridable +ovrridables,overridables +ovrwrt,overwrite +ovservable,observable +ovservation,observation +ovserve,observe +ovveride,override +ovverridden,overridden +ovverride,override +ovverrides,overrides +ovverriding,overriding +owerflow,overflow owernship,ownership owerpowering,overpowering +owership,ownership +owervrite,overwrite +owervrites,overwrites +owerwrite,overwrite +owerwrites,overwrites +owful,awful +ownder,owner ownders,wonders +ownerhsip,ownership +ownes,owns,ones +ownner,owner +ownward,onward +ownwer,owner +ownwership,ownership owrk,work owudl,would owuldve,wouldve oxigen,oxygen oximoron,oxymoron +oxzillary,auxiliary oylmpic,olympic oylmpics,olympics +oyu,you +paackage,package pacakge,package pacakged,packaged +pacakges,packages +pacakging,packaging +paceholder,placeholder +pach,patch,path +pachage,package +paches,patches +pacht,patch +pachtches,patches +pachtes,patches pacificts,pacifist pacifit,pacifist +pacjage,package +pacjages,packages +packacge,package packade,packaged packadge,packaged +packaeg,package +packaege,package +packaeges,packages +packaegs,packages +packag,package packageid,packaged +packaing,packaging +packe,packed,packet +packege,package packge,package +packged,packaged +packgement,packaging +packges,packages +packhage,package +packhages,packages +packtes,packets +pactch,patch +pactched,patched +pactches,patches pacthes,patches pactivity,captivity +padam,param +pading,padding +paermission,permission +paermissions,permissions +paeth,path paficist,pacifist +pagagraph,paragraph pahntom,phantom +pahses,phases +paht,path,pat,part pahtfinder,pathfinder +pahts,paths,pats,parts paide,paid +paied,paid,paired painfullly,painfully painfuly,painfully +painiting,painting painkilers,painkillers painkilllers,painkillers painkills,painkillers +paintile,painttile +paintin,painting pairlament,parliament paitence,patience paitent,patient paitently,patiently paitents,patients paitience,patience +paiting,painting +pakage,package +pakageimpl,packageimpl +pakages,packages +pakcage,package +paket,packet +pakge,package pakistain,pakistani pakistanais,pakistani pakistanezi,pakistani @@ -18175,14 +34264,17 @@ pakistanti,pakistani pakistian,pakistani pakistnai,pakistani paksitani,pakistani +pakvage,package paladines,paladins paladinlst,paladins paladinos,paladins palastinians,palestinians -palce,place +palatte,palette +palce,place,palace palcebo,placebo palceholder,placeholder palcements,placements +palces,places,pales paleolitic,paleolithic palesitnian,palestinians palesitnians,palestinians @@ -18199,14 +34291,19 @@ palestinier,palestine palestininan,palestinian palestininans,palestinians palestininas,palestinians +palete,palette paliamentarian,parliamentarian palidans,paladins palistian,palestinian palistinian,palestinian palistinians,palestinians pallete,palette +pallette,palette +palletted,paletted +paln,plan,pain,palm palster,plaster palstics,plastics +paltette,palette paltform,platform paltformer,platformer paltforms,platforms @@ -18229,12 +34326,18 @@ pandorra,pandora pandroa,pandora panedmic,pandemic panethon,pantheon +paniced,panicked +panicing,panicking pankaces,pancakes panmedic,pandemic +pannel,panel +pannels,panels pantehon,pantheon panthen,pantheon panthoen,pantheon pantomine,pantomime +paoition,position +paor,pair papanicalou,papanicolaou parachutage,parachute parachutte,parachute @@ -18242,44 +34345,106 @@ parademics,paramedics paradies,paradise paradiggum,paradigm paradim,paradigm +paradime,paradigm paradimes,paradise paradse,parades +paradym,paradigm paradyse,parades +paraemeter,parameter +paraemeters,parameters +paraeters,parameters +parafanalia,paraphernalia +paragaph,paragraph +paragaraph,paragraph +paragarapha,paragraph +paragarph,paragraph +paragarphs,paragraphs +paragph,paragraph +paragpraph,paragraph paragraghs,paragraphs paragrah,paragraph paragrahps,paragraphs paragrapgh,paragraphs paragraphes,paragraphs +paragraphy,paragraph paragraps,paragraphs paragrpah,paragraph paragrpahs,paragraphs +paragrphs,paragraphs +parahaps,perhaps parahprase,paraphrase paraiste,parasite paralel,parallel +paralelising,parallelising +paralelism,parallelism +paralelizing,parallelizing paralell,parallel +paralelle,parallel +paralellism,parallelism +paralellization,parallelization paralells,parallels paralelly,parallelly paralely,parallelly paralisys,paralysis paralleles,parallels +parallell,parallel parallells,parallels parallely,parallelly paralles,parallels +parallization,parallelization +parallize,parallelize +parallized,parallelized +parallizes,parallelizes +parallizing,parallelizing paralzyed,paralyzed paramadics,paramedics +paramameters,parameters +paramater,parameter paramaters,parameters paramecias,paramedics paramedicks,paramedics paramedicos,paramedics paramedis,paramedics parameds,paramedics +paramemeter,parameter +paramemeters,parameters +paramemter,parameter +paramemters,parameters +paramenet,parameter +paramenets,parameters +paramenters,parameters +paramer,parameter +paramert,parameter +paramerters,parameters +paramerts,parameters +parameteras,parameters +parametere,parameter,parameters parameteres,parameters +parameterical,parametrical +parameterts,parameters +parametes,parameters +parametic,parametric,paramedic parametics,paramedics +parametised,parametrised +parametr,parameter parametros,parameters +parametter,parameter +parametters,parameters paramiters,parameters paramormal,paranormal +paramss,params paramter,parameter +paramterer,parameter +paramterers,parameters +paramteres,parameters +paramterical,parametric,parametrically +paramterization,parametrization,parameterization +paramterize,parameterize +paramterless,parameterless paramters,parameters +paramtrical,parametrical +parana,piranha +paraniac,paranoiac paranioa,paranoia paraniod,paranoid paranoa,paranoia @@ -18288,7 +34453,11 @@ paranoicas,paranoia paranoida,paranoia paranomral,paranormal paranornal,paranormal +paranoya,paranoia +paranthes,parentheses,parenthesis +parantheses,parentheses paranthesis,parenthesis +paraphanalia,paraphernalia parapharse,paraphrase parapharsed,paraphrase parapharsing,paraphrasing @@ -18302,23 +34471,54 @@ paraprashing,paraphrasing paraprhase,paraphrase paraprhased,paraphrase paraprhasing,paraphrasing +pararagraph,paragraph +pararaph,paragraph +parareter,parameter +parargaph,paragraph +parargaphs,paragraphs +pararmeters,parameters paraside,paradise parasitisme,parasites parasits,parasites parasitter,parasite +parastic,parasitic +parastics,parasitics parastie,parasite parasties,parasites +paratmers,parameters +paravirutalisation,paravirtualisation +paravirutalise,paravirtualise +paravirutalised,paravirtualised +paravirutalization,paravirtualization +paravirutalize,paravirtualize +paravirutalized,paravirtualized paraylsis,paralysis paraylzed,paralyzed +parctical,practical +parctically,practically parctise,practise +pard,part +parellelogram,parallelogram parellels,parallels +parem,param +paremeter,parameter +paremeters,parameters paremsan,parmesan +paremter,parameter +paremters,parameters +parentesis,parentheses,parenthesis parenthasis,parenthesis +parenthese,parentheses +parenthesed,parenthesized parenthesees,parentheses parenthesies,parenthesis parenthesys,parentheses -parenthises,parenthesis +parenthises,parenthesis,parentheses parenthisis,parenthesis +parenthsis,parenthesis +paret,parent,parrot +parial,partial +parially,partially paricular,particular parilament,parliament parilamentary,parliamentary @@ -18327,6 +34527,11 @@ parisitic,parasitic paristan,partisan paritally,partially parites,parties +paritial,partial +parition,partition +paritioning,partitioning +paritition,partition +parititions,partitions parituclar,particular parlaiment,parliament parlaimentary,parliamentary @@ -18341,10 +34546,22 @@ parliamone,parliament parliement,parliament parliementary,parliamentary parliment,parliament +parm,param,pram,parma +parmaeter,parameter +parmaeters,parameters +parmameter,parameter +parmameters,parameters parmasen,parmesan +parmaters,parameters parmenas,parmesan parmesaen,parmesan +parmeter,parameter +parmeters,parameters +parms,params,prams parmsean,parmesan +parmter,parameter +parmters,parameters +parnoia,paranoia parntered,partnered parnters,partners parntership,partnership @@ -18353,6 +34570,11 @@ parrallel,parallel parrallell,parallel parrallelly,parallelly parrallely,parallelly +parrent,parent +parseing,parsing +parsering,parsing +parsin,parsing +partaining,pertaining partchett,pratchett partecipant,participant partecipants,participants @@ -18366,9 +34588,24 @@ partialy,partially partians,partisan partiarchal,patriarchal partiarchy,patriarchy -partical,particular +partical,particular,partial,particle +particalar,particular +particalarly,particularly +particale,particle +particales,particles +partically,partially +particals,particles +particaluar,particular +particaluarly,particularly +particalur,particular +particalurly,particularly +particant,participant particapate,participate particapated,participated +particaular,particular +particaularly,particularly +particaulr,particular +particaulrly,particularly partice,particle particel,particle particiapnts,participant @@ -18401,6 +34638,8 @@ particpiate,participated particually,particularly particualr,particular particualrly,particularly +particuar,particular +particuarly,particularly particulalry,particularly particulaly,particularly particularely,particularly @@ -18410,24 +34649,61 @@ particulary,particularly particullary,particularly partiel,particle partiets,parties +partifular,particular +partiiton,partition +partiitoned,partitioned +partiitoning,partitioning +partiitons,partitions +partion,partition,portion +partioned,partitioned +partioning,partitioning,portioning +partions,partitions,portions partiot,patriot partiotic,patriotic partiotism,patriotism partiots,patriots +partirion,partition +partirioned,partitioned +partirioning,partitioning +partirions,partitions partisain,partisan +partision,partition +partisioned,partitioned +partisioning,partitioning +partisions,partitions +partitial,partial +partiticular,particular +partitioing,partitioning +partitiones,partitions +partiton,partition +partitoned,partitioned +partitoning,partitioning +partitons,partitions partizipation,participation partnerd,partnered partnetship,partnership partols,patrols partonizing,patronizing partsian,partisan -pased,passed +pary,party,parry +pase,pass,pace,parse +pased,passed,parsed pasengers,passengers +paser,parser +pasesd,passed +pash,hash +pasing,passing,posing +pasitioning,positioning +pasive,passive +pasre,parse +pasred,parsed +pasres,parses passabe,passable passabel,passable passagens,passages passagers,passages passerbys,passersby +passin,passing passionais,passions passionale,passionately passionant,passionate @@ -18440,42 +34716,72 @@ passionetly,passionately passionite,passionate passionnate,passionate passisve,passives +passiv,passive passivedns,passives passivelly,passively passivley,passively passivs,passives +passowrd,password passowrds,passwords passporters,passports passpost,passports +passthrought,passthrough +passthruogh,passthrough +passtime,pastime +passtrough,passthrough passvies,passives +passwird,password +passwirds,passwords passwors,passwords +passwrod,password +passwrods,passwords +pasteing,pasting pasttime,pastime pastural,pastoral pasuing,pausing +pasword,password +paswords,passwords +patchs,patches,paths +patcket,packet +patckets,packets pateince,patience pateint,patient pateintly,patiently pateints,patients patenterad,patented +patern,pattern +paterns,patterns patethic,pathetic pathalogical,pathological +pathane,pathname +pathced,patched pathces,patches patheitc,pathetic pathelogical,pathological +pathes,paths pathfidner,pathfinder pathfindir,pathfinder pathifnder,pathfinder +pathign,pathing +pathnme,pathname +patholgoical,pathological patholigical,pathological pathologial,pathological +patial,spatial paticular,particular +paticularly,particularly patiens,patients patientens,patients patienty,patiently patinetly,patiently patirot,patriot patirots,patriots +patition,partition patrairchy,patriarchy patrcik,patrick +patren,patron,pattern +patrens,patron,patterns +patrent,parent,patent,patron patriachry,patriarchy patriarca,patriarchal patriarcal,patriarchal @@ -18507,11 +34813,16 @@ patronis,patrons patronos,patrons patronozing,patronizing patryarchy,patriarchy -pattened,patented +patten,pattern,patent +pattened,patented,patterned +pattens,patterns,patents pattented,patented patterno,patterson -pattersn,patterson +pattersn,patterson,patterns +pattren,pattern,patron +pattrens,patterns,patrons pavillion,pavilion +pavillions,pavilions paychedelics,psychedelics paychiatrist,psychiatrist paychiatrists,psychiatrists @@ -18520,10 +34831,13 @@ paychologist,psychologist paychologists,psychologists paychopathic,psychopathic payed,paid +paínt,paint pblisher,publisher pbulisher,publisher +peacd,peace peacefullly,peacefully peacefuly,peacefully +peacify,pacify peageant,pageant peaple,people peaples,peoples @@ -18531,9 +34845,13 @@ pebbels,pebbles pebbleos,pebbles pebblers,pebbles pebblets,pebbles +pecentage,percentage +pecified,specified,pacified peciluar,peculiar pecuilar,peculiar peculair,peculiar +pecularities,peculiarities +pecularity,peculiarity peculure,peculiar pedantisch,pedantic pedestiran,pedestrian @@ -18541,6 +34859,8 @@ pedestirans,pedestrians pedestrain,pedestrian pedestrains,pedestrians pedictions,depictions +peding,pending +pedning,pending pedohpile,pedophile pedohpiles,pedophiles pedohpilia,pedophilia @@ -18554,18 +34874,37 @@ pedophille,pedophile pedophilles,pedophile pedophils,pedophiles pedopholia,pedophilia +peference,preference +peferences,preferences +peform,perform +peformance,performance peformed,performed +peforming,performing +pege,page peice,piece +peicemeal,piecemeal +peices,pieces +peicewise,piecewise peirced,pierced peircing,piercing peircings,piercings +peirod,period +peirodical,periodical +peirodicals,periodicals +peirods,periods +peloponnes,peloponnese,peloponnesus penalites,penalties +penalities,penalties +penality,penalty penaltis,penalties penatgon,pentagon penatlies,penalties penatly,penalty penciles,pencils +pendantic,pedantic pendatic,pedantic +pendig,pending +pendning,pending pendulm,pendulum penduluum,pendulum penerator,penetrator @@ -18594,6 +34933,8 @@ penisula,peninsula penisular,peninsular penisylvania,pennsylvania penitum,pentium +pennal,panel +pennals,panels penninsula,peninsula penninsular,peninsular pennisula,peninsula @@ -18615,6 +34956,7 @@ penssylvania,pennsylvania pentagoon,pentagon pentsylvania,pennsylvania pentuim,pentium +penultimante,penultimate peodphile,pedophile peodphiles,pedophiles peodphilia,pedophilia @@ -18622,14 +34964,19 @@ peom,poem peoms,poems peopel,people peopels,peoples +peopl,people peotry,poetry +pepare,prepare +peported,reported,purported pepperin,pepperoni pepperino,pepperoni pepperment,peppermint peppermit,peppermint pepperocini,pepperoni pepperonni,pepperoni +peprocessor,preprocessor perade,parade +peraphs,perhaps percantage,percentage percantages,percentages percantile,percentile @@ -18641,6 +34988,7 @@ percentagens,percentages percente,percentile percential,percentile percentige,percentile +percentil,percentile percentille,percentile percepted,perceived perceptoin,perceptions @@ -18675,45 +35023,149 @@ peremiter,perimeter perenially,perennially perephirals,peripherals pereptually,perpetually +peresent,present,presents,presence,percent +peretrator,perpetrator +perfec,perfect perfeccion,perfection +perfecct,perfect +perfecctly,perfectly perfeclty,perfectly +perfecly,perfectly +perfectably,perfectly perfecty,perfectly perfecxion,perfection perfektion,perfection +perfer,prefer perferable,preferable perferably,preferably +perferance,preference +perferances,preferences +perferct,perfect +perferctly,perfectly +perferect,perfect +perferectly,perfectly +perfered,preferred perference,preference perferences,preferences perferential,preferential +perferm,perform +perfermance,performance +perfermances,performances +perfermence,performance +perfermences,performances +perferr,prefer +perferrable,preferable +perferrably,preferably +perferrance,preference +perferrances,preferences +perferred,preferred +perferrence,preference +perferrences,preferences perferring,preferring +perferrm,perform +perferrmance,performance +perferrmances,performances +perferrmence,performance +perferrmences,performances +perferrs,prefers perfers,prefers perfexcion,perfection +perfix,prefix +perfmormance,performance +perfoem,perform +perfoemamce,performance +perfoemamces,performances +perfoemance,performance +perfoemanse,performance +perfoemanses,performances +perfoemant,performant +perfoemative,performative +perfoemed,performed +perfoemer,performer +perfoemers,performers +perfoeming,performing +perfoemnace,performance +perfoemnaces,performances +perfoems,performs +perfom,perform +perfomamce,performance +perfomamces,performances perfomance,performance +perfomanse,performance +perfomanses,performances +perfomant,performant +perfomative,performative +perfome,perform +perfomeamce,performance +perfomeamces,performances +perfomeance,performance +perfomeanse,performance +perfomeanses,performances +perfomeant,performant +perfomeative,performative +perfomed,performed +perfomeed,performed +perfomeer,performer +perfomeers,performers +perfomeing,performing +perfomenace,performance +perfomenaces,performances +perfomer,performer perfomers,performers -perfomrance,performances +perfomes,performs +perfoming,performing +perfomnace,performance +perfomnaces,performances +perfomr,perform +perfomramce,performance +perfomramces,performances +perfomrance,performances,performance +perfomranse,performance +perfomranses,performances +perfomrant,performant +perfomrative,performative +perfomred,performed +perfomrer,performer +perfomrers,performers +perfomring,performing +perfomrnace,performance +perfomrnaces,performances +perfomrs,performs +perfoms,performs +perfoom,perfume,perform perforamnce,performances +perforemd,performed performace,performance performaces,performances performacne,performances +performaed,performed +performamce,performance performancepcs,performances performancetest,performances performancewise,performances -performane,performances +performane,performances,performance performanes,performances performans,performances performanse,performances performantes,performances performas,performs +performe,perform,performed performence,performance performences,performances performens,performers -performnace,performances +performes,performed,performs +performnace,performances,performance performous,performs +perfrom,perform perfromance,performance perfromances,performances +perfromed,performed perfromer,performer perfromers,performers +perfroming,performing perfroms,performs +perhabs,perhaps +perhas,perhaps perhasp,perhaps perheaps,perhaps perhiperal,peripheral @@ -18721,6 +35173,7 @@ perhiperals,peripherals perhpas,perhaps pericing,piercing pericings,piercings +peridic,periodic peridinkle,periwinkle peridoic,periodic peridoically,periodically @@ -18728,8 +35181,11 @@ perihperal,peripheral perihperals,peripherals perimetr,perimeter perimetre,perimeter +perimetres,perimeters +periode,period periodes,periods periodicaly,periodically +periodioc,periodic periodisch,periodic periodos,periods peripathetic,peripatetic @@ -18748,6 +35204,7 @@ periphreals,peripherals periphrial,peripheral periphrials,peripherals perisan,persian +perisist,persist peristent,persistent peritinkle,periwinkle periwankle,periwinkle @@ -18757,8 +35214,10 @@ periwinkie,periwinkle periwinlke,periwinkle perjery,perjury perjorative,pejorative +perlciritc,perlcritic perliminary,preliminary permade,premade +permament,permanent permamently,permanently permanant,permanent permanantely,permanently @@ -18767,11 +35226,13 @@ permanentely,permanently permanenty,permanently permanet,permanent permanetly,permanently +permantly,permanently permature,premature permaturely,prematurely permenant,permanent permenantly,permanently permenently,permanently +permessioned,permissioned permier,premier permiere,premiere permieter,perimeter @@ -18779,7 +35240,8 @@ perminantly,permanently perminently,permanently permise,premise permises,premises -permisions,permission +permision,permission +permisions,permission,permissions permisison,permissions permisisons,permissions permissble,permissible @@ -18787,22 +35249,35 @@ permissiable,permissible permissibe,permissible permissie,permissible permissin,permissions +permissiosn,permissions permisson,permission permissons,permissions -permisssion,permissions +permisssion,permissions,permission +permisssions,permissions permitas,permits +permited,permitted permites,permits +permition,permission +permitions,permissions permitis,permits permitts,permits permium,premium permiums,premiums +permormance,performance +permuation,permutation +permuations,permutations +permutaion,permutation +permutaions,permutations pernament,permanent pernamently,permanently +peroendicular,perpendicular perogative,prerogative +peroid,period peroidic,periodic peroidically,periodically peroids,periods peronal,personal +peroperly,properly perordered,preordered perorders,preorders perosnality,personality @@ -18824,7 +35299,9 @@ perpenticular,perpendicular perpertated,perpetuated perpertator,perpetrators perpertators,perpetrators +perperties,properties perpertrated,perpetrated +perperty,property perpetraded,perpetrated perpetrador,perpetrator perpetraitor,perpetrator @@ -18861,6 +35338,7 @@ perputuated,perpetuated perputuates,perpetuates perputuating,perpetuating perrogative,prerogative +perrror,perror persain,persian persan,person persaude,persuade @@ -18879,22 +35357,31 @@ persecutin,persecution persecutted,persecuted persepctive,perspective persepctives,perspectives +persepective,perspective +persepectives,perspectives perservation,preservation perserve,preserve perserved,preserved +perserverance,perseverance +perserves,preserves perserving,preserving persets,presets perseverence,perseverance persicuted,persecuted persicution,persecution persisit,persist +persisited,persisted persistance,persistence persistant,persistent persistante,persistent +persistantly,persistently +persisten,persistent persistens,persists persistense,persistence persistente,persistence +persistented,persisted persistes,persists +persited,persisted persits,persist persoanlly,personally persocuted,persecuted @@ -18902,19 +35389,22 @@ personaes,personas personalie,personalized personalis,personas personalites,personalities +personalitie,personality personalitites,personalities personalitits,personalities +personalitys,personalities personallity,personally personaly,personally personarse,personas personatus,personas -personel,personnel +personel,personnel,personal personell,personnel persones,persons personhod,personhood personhoood,personhood personilized,personalized personis,persons +personnal,personal personnell,personnel personsa,personas perspecitve,perspective @@ -18955,8 +35445,19 @@ perticularly,particularly pertinante,pertinent pertinet,pertinent pertoleum,petroleum +pertrub,perturb +pertrubation,perturbation +pertrubations,perturbations +pertrubing,perturbing +pertub,perturb +pertubate,perturb +pertubated,perturbed +pertubates,perturbs pertubation,perturbation pertubations,perturbations +pertubing,perturbing +perturbate,perturb +perturbates,perturbs perusaded,persuaded pervail,prevail pervailing,prevailing @@ -18969,6 +35470,7 @@ pervertes,perverse perview,preview perviews,previews pervious,previous +perviously,previously perxoide,peroxide pesitcides,pesticides pessiary,pessary @@ -18988,6 +35490,9 @@ pestizides,pesticides petetion,petition petrolem,petroleum petroluem,petroleum +pevent,prevent +pevents,prevents +pezier,bezier phantoom,phantom pharamceutical,pharmaceutical pharamceuticals,pharmaceutical @@ -19007,6 +35512,8 @@ pharmeceutical,pharmaceutical pharmicist,pharmacist pharmsci,pharmacist pharoah,pharaoh +phasepsace,phasespace +phasis,phases phatnom,phantom phemonena,phenomena phemonenon,phenomenon @@ -19032,6 +35539,7 @@ phenonema,phenomena phenonemal,phenomenal phenonemon,phenomenon phenonmena,phenomena +pheriparials,peripherals phialdelphia,philadelphia philadalphia,philadelphia philadelhpia,philadelphia @@ -19095,12 +35603,18 @@ philospohical,philosophical philospohies,philosophies philospohy,philosophy phisiological,physiological +phisosophy,philosophy phonecian,phoenecian phonemena,phenomena +phoneticly,phonetically phongraph,phonograph photagrapher,photographer photagraphers,photographers +phote,photo photochopped,photoshopped +photografic,photographic +photografical,photographical +photografy,photography photogragh,photograph photograh,photograph photograhed,photographed @@ -19120,6 +35634,7 @@ photographied,photographed photographier,photographer photographyi,photographic photograpic,photographic +photograpical,photographical photograpphed,photographed photograps,photographs photograpy,photography @@ -19152,6 +35667,8 @@ phsyics,physics phsyiological,physiological phsyiology,physiology phsyique,physique +phtread,pthread +phtreads,pthreads phychedelics,psychedelics phychiatrist,psychiatrist phychiatrists,psychiatrists @@ -19187,6 +35704,7 @@ physcology,psychology physcopath,psychopath physcopathic,psychopathic physcopaths,psychopaths +physial,physical physicallity,physically physicaly,physically physicials,physicians @@ -19200,16 +35718,24 @@ physioligy,physiology physiologial,physiological physiqe,physique physisict,physicist +physisist,physicist physqiue,physique +phython,python +phyton,python piankillers,painkillers piblisher,publisher pich,pitch +picoseond,picosecond +picoseonds,picoseconds picthed,pitched picther,pitcher picthers,pitchers picthes,pitches picthfork,pitchfork picthforks,pitchforks +pieceweise,piecewise +piecewiese,piecewise +piecwise,piecewise piegons,pigeons piglrim,pilgrim pigoens,pigeons @@ -19219,6 +35745,8 @@ pilgrimmages,pilgrimages pillards,pillars pillaris,pillars pilrgim,pilgrim +pimxap,pixmap +pimxaps,pixmaps pinancle,pinnacle pinapple,pineapple pinetrest,pinterest @@ -19233,6 +35761,23 @@ pinteret,pinterest piolting,piloting pioneeer,pioneer pionere,pioneer +piont,point +pionter,pointer +pionts,points +piority,priority +pipeine,pipeline +pipeines,pipelines +pipelin,pipeline +pipelinining,pipelining +pipelins,pipelines +pipepline,pipeline +pipeplines,pipelines +pipiline,pipeline +pipilines,pipelines +pipleine,pipeline +pipleines,pipelines +pipleline,pipeline +piplelines,pipelines pireced,pierced pitchferks,pitchforks pitchfolks,pitchforks @@ -19244,21 +35789,43 @@ pitchworks,pitchforks pitckforks,pitchforks pithcers,pitchers pithces,pitches +pitmap,pixmap,bitmap pittaburgh,pittsburgh pittsbrugh,pittsburgh +pitty,pity +pivott,pivot +pivotting,pivoting +pixelx,pixels,pixel +pixes,pixels pkaythroughs,playthroughs plabeswalker,planeswalker placebro,placebo +placeemnt,placement +placeemnts,placements placeheld,placeholder placehoder,placeholder +placeholde,placeholder +placeholdes,placeholders placeholdr,placeholder placeholer,placeholder -placemenet,placements +placeholers,placeholders +placematt,placemat,placement +placemenet,placements,placement +placemenets,placements placemens,placements -placemet,placements +placemet,placements,placement,placemat +placemets,placements,placemats +placholder,placeholder +placholders,placeholders +placmenet,placement +placmenets,placements plaestine,palestine plaestinian,palestinian plaestinians,palestinians +plaform,platform +plaforms,platforms +plaftorm,platform +plaftorms,platforms plagairism,plagiarism plagarisim,plagiarism plagarism,plagiarism @@ -19270,6 +35837,8 @@ plagiarizm,plagiarism plagierism,plagiarism plaguarism,plagiarism plaigarism,plagiarism +plalform,platform +plalforms,platforms planatery,planetary planation,plantation planeswaker,planeswalker @@ -19285,8 +35854,15 @@ plansewalker,planeswalker plansewalkers,planeswalker planteary,planetary plantes,planets +plantext,plaintext plantiff,plaintiff plantium,platinum +plase,place,please,phase,plaice +plased,placed,pleased,phased +plasement,placement +plasements,placements +plases,places,pleases,phases +plasing,placing,pleasing,phasing plasitcs,plastics plasticas,plastics plasticos,plastics @@ -19297,19 +35873,40 @@ plastre,plaster plataeu,plateau plateu,plateau plateua,plateau +platfarm,platform platfarmer,platformer +platfarms,platforms +platfform,platform +platfforms,platforms +platflorm,platform +platflorms,platforms +platfoem,platform +platfom,platform +platforma,platforms platformar,platformer platformie,platformer +platformt,platforms platfotmer,platformer platfrom,platform platfromer,platformer platfromers,platformer platfroms,platforms +plathome,platform platimun,platinum platnium,platinum platnuim,platinum +platofmr,platform +platofmrs,platforms +platofms,platforms +platofmss,platforms +platoform,platform +platoforms,platforms +platofrm,platform platofrmer,platformer platofrms,platforms +plattform,platform +plattforms,platforms +plausability,plausibility plausable,plausible plausbile,plausible plausibe,plausible @@ -19317,8 +35914,13 @@ plausibel,plausible plauthroughs,playthroughs playabe,playable playaround,playground +playble,playable playbody,playboy playersare,playerbase +playfull,playful,playfully +playge,plague +playgerise,plagiarise +playgerize,plagiarize playgorund,playground playgroud,playground playhtrough,playthrough @@ -19347,47 +35949,126 @@ playtrhough,playthrough playtrhoughs,playthroughs playwrite,playwright playwrites,playwrights +pleaase,please +pleace,please,place +pleacing,placing +pleae,please +pleaee,please +pleaes,please +pleasd,pleased pleasent,pleasant +pleasently,pleasantly +pleass,pleases,bless plebicite,plebiscite +plecing,placing plehtora,plethora +plent,plenty pleothra,plethora +plesae,please plesant,pleasant +plese,please +plesently,pleasantly +plesing,pleasing,blessing plethoria,plethora plethorian,plethora plethroa,plethora +plian,plain,pliant pligrim,pilgrim +pllatforms,platforms ploarized,polarized ploretariat,proletariat +ploting,plotting ploygamy,polygamy ploygon,polygon ploymer,polymer +pltform,platform +pltforms,platforms +plugable,pluggable +pluged,plugged +pluging,plugging,plugin +pluign,plugin +pluigns,plugins +pluse,pulse +plyotropy,pleiotropy pnatheon,pantheon +pobular,popular +pobularity,popularity +pocess,process,possess +pocessed,processed,possessed +pocession,procession,possession podemso,podemos podmeos,podemos +podule,module poenis,penis +poential,potential +poentially,potentially +poentials,potentials poeoples,peoples +poeple,people poeples,peoples +poer,power poety,poetry +pogress,progress +poicies,policies +poicy,policy poignat,poignant +poind,point +poindcloud,pointcloud poineer,pioneer +poiner,pointer +poing,point poingant,poignant +poinits,points +poinnter,pointer +poins,points pointeres,pointers -pointes,pointers +pointes,pointers,points +pointetr,pointer +pointetrs,pointers pointeur,pointer +pointseta,poinsettia +pointss,points pointure,pointer +pointzer,pointer +poinyent,poignant poisin,poison +poisition,position +poisitioned,positioned +poisitioning,positioning +poisitionning,positioning +poisitions,positions poisond,poisoned poisones,poisons poisonis,poisons poisonos,poisons poisonus,poisons +poistion,position +poistioned,positioned +poistioning,positioning +poistions,positions +poit,point +poiter,pointer +poiters,pointers +poitn,point +poitner,pointer +poitning,pointing +poits,points +poiunter,pointer +poject,project +pojecting,projecting +pojnt,point +poket,pocket +polariy,polarity polgyamy,polygamy polgyon,polygon polical,political +policie,policies,policy,police policitally,politically policitian,politician policitians,politicians polietly,politely +poligon,polygon +poligons,polygons polinator,pollinator polinators,pollinators polishees,polishes @@ -19401,12 +36082,13 @@ politicain,politician politicains,politicians politicaly,politically politican,politician +politicans,politicians politicanti,politician politicas,politics politicien,politician politiciens,politicians politicin,politician -politicing,politician +politicing,politician,politicking politicion,politician politickin,politician politicus,politics @@ -19417,24 +36099,65 @@ politing,piloting polititian,politician polititians,politicians politley,politely +pollenate,pollinate +polltry,poultry +pologon,polygon +pologons,polygons poltical,political +poltry,poultry polute,pollute poluted,polluted polutes,pollutes poluting,polluting polution,pollution +polyar,polar +polyedral,polyhedral polygammy,polygamy +polygond,polygons +polygone,polygon polygoon,polygon +polylon,polygon,pylon polymore,polymer +polymorpic,polymorphic polyphonyic,polyphonic +polypoygon,polypolygon +polypoylgons,polypolygons polysaccaride,polysaccharide +polysaccharid,polysaccharide pomegranite,pomegranate pomotion,promotion +pompay,pompeii +poninter,pointer +poniter,pointer +pont,point +pontential,potential +ponter,pointer +ponting,pointing +ponts,points +pontuation,punctuation +pooint,point +poointed,pointed +poointer,pointer +pooints,points +poost,post +poped,popped,pooped +poperee,potpourri +poperly,properly,property +poperties,properties +poperty,property,properly +poping,popping,pooping popluar,popular popluations,populations +popoen,popen +popolate,populate +popolated,populated +popolates,populates +popolating,populating poportional,proportional popoulation,population popoulus,populous +popoup,popup +poppup,popup popualtion,populations populair,popular populairty,popularity @@ -19451,16 +36174,42 @@ populatiry,popularity populative,populate populatoin,populations populer,popular +popullate,populate +popullated,populated populos,populous popultaion,populations +popuplar,popular +popuplarity,popularity +popuplate,populate +popuplated,populated +popuplates,populates +popuplating,populating +popuplation,population poralized,polarized +porblem,problem +porblems,problems porcelan,porcelain porcelian,porcelain porcelina,porcelain +porcess,process +porcessed,processed +porcesses,processes +porcessing,processing +porcessor,processor +porcessors,processors poreclain,porcelain porftolio,portfolio +porgram,program porgramme,programme +porgrammeer,programmer +porgrammeers,programmers +porgramming,programming +porgrams,programs +poriferal,peripheral +porject,project porjectiles,projectiles +porjection,projection +porjects,projects porletariat,proletariat pormetheus,prometheus pornagraphy,pornography @@ -19473,12 +36222,16 @@ pornograpy,pornography pornogrophy,pornography pornogrpahy,pornography pornogrphy,pornography +porotocol,protocol +porotocols,protocols +porperty,property porportion,proportion porportional,proportional porportionally,proportionally porportions,proportions porpose,propose porposes,proposes +porsalin,porcelain porshan,portion porshon,portion portabel,portable @@ -19486,17 +36239,22 @@ portabillity,portability portabilty,portability portagonists,protagonists portait,portrait +portaits,portraits portalis,portals portalus,portals portary,portray portarying,portraying portayed,portrayed +portected,protected portestants,protestants portfoilo,portfolio portgual,portugal +portguese,portuguese +portioon,portion portoflio,portfolio portoguese,portuguese portraiing,portraying +portrail,portrayal,portrait portraing,portraying portrais,portraits portrary,portray @@ -19515,16 +36273,33 @@ portuguease,portuguese portugues,portuguese portuguesse,portuguese portuguise,portuguese +posative,positive +posatives,positives +posativity,positivity +poseesions,possessions posess,possess posessed,possessed posesses,possesses posessing,possessing posession,possession posessions,possessions +posibilities,possibilities +posibility,possibility +posibilties,possibilities +posible,possible +posiblity,possibility +posibly,possibly posicional,positional -posion,poison -posioned,poisoned +posiitive,positive +posiitives,positives +posiitivity,positivity +posion,poison,psion +posioned,poisoned,positioned +posioning,poisoning posions,poisons +posisition,position +posisitioned,positioned +posistion,position positevely,positively positioing,positioning positiond,positioned @@ -19532,12 +36307,18 @@ positiong,positioning positionial,positional positionl,positional positionly,positional +positionn,position positionnal,positional positionne,positioned positionned,positioned +positionnes,positions positionning,positioning +positionns,positions +positionof,position +positiv,positive positiveity,positivity positiviely,positively +positivies,positives positivisme,positives positivisty,positivity positivitely,positivity @@ -19547,15 +36328,33 @@ positiviy,positivity positivley,positively positivs,positives positivy,positivity -positon,position +positoin,position +positoined,positioned +positoins,positions +positon,position,positron +positoned,positioned +positoning,positioning +positons,positions,positrons positve,positive +positves,positives +pospone,postpone +posponed,postponed +posption,position +possabilites,possibilities +possabilities,possibilities +possability,possibility +possabilties,possibilities +possabily,possibly possable,possible possably,possibly possbily,possibly +possble,possible +possbly,possibly posseses,possesses possesess,possesses possesing,possessing possesion,possession +possesive,possessive possesives,possessive possesse,possessive possessers,possesses @@ -19566,31 +36365,90 @@ possessivize,possessive possesss,possesses possesssion,possessions possestions,possessions +possiable,possible +possibbe,possible +possibe,possible possibile,possible +possibilies,possibilities +possibilites,possibilities +possibilitities,possibilities possibiliy,possibility possibillity,possibility +possibilties,possibilities possibilty,possibility -possibily,possibility +possibily,possibility,possibly +possiblble,possible +possiblec,possible +possiblely,possibly possibley,possibly possiblility,possibility possiblilty,possibility possiblities,possibilities +possiblity,possibility possiblly,possibly possiby,possibly +possilbe,possible +possily,possibly possissive,possessive possition,position +possitive,positive +possitives,positives +possobily,possibly +possoble,possible +possobly,possibly +posssible,possible +postcondtion,postcondition +postcondtions,postconditions postdam,potsdam +postgress,postgresql +postgressql,postgresql +postgrsql,postgresql posthomous,posthumous +postiional,positional +postiive,positive +postincremend,postincrement postion,position +postioned,positioned +postions,positions +postition,position postive,positive +postives,positives +postmage,postimage +postphoned,postponed +postpocessing,postprocessing +postponinig,postponing +postprocesing,postprocessing +postscritp,postscript +postulat,postulate +postuminus,posthumous +postumus,posthumous +potatoe,potato potatos,potatoes +potencial,potential potencially,potentially +potencials,potentials +potenial,potential +potenially,potentially +potentail,potential potentailly,potentially +potentails,potentials +potental,potential +potentally,potentially +potentatially,potentially +potententially,potentially +potentiallly,potentially potentialy,potentially +potentiel,potential +potentiomenter,potentiometer potical,optical +potition,position +potocol,protocol potrait,portrait potrayed,portrayed poulations,populations +pount,point +pounts,points +poupular,popular poverful,powerful powderade,powdered powderd,powdered @@ -19609,13 +36467,17 @@ powerlifitng,powerlifting powerliftng,powerlifting powerlisting,powerlifting powerpot,powerpoint +powerppc,powerpc powerprint,powerpoint powersehll,powershell powetlifting,powerlifting powrrlifting,powerlifting poylgon,polygon poylmer,polymer +ppolygons,polygons ppublisher,publisher +praameter,parameter +praameters,parameters pracitcal,practical pracitcally,practically pracitse,practise @@ -19630,6 +36492,7 @@ practicioner,practitioner practicioners,practitioners practiclly,practically practicly,practically +practicval,practical practie,practise practies,practise practioner,practitioner @@ -19641,58 +36504,137 @@ practitionner,practitioner practitionners,practitioners practitions,practitioners practives,practise +pragam,pragma pragamtic,pragmatic pragmatisch,pragmatic prairy,prairie praisse,praises +pramater,parameter +prameter,parameter +prameters,parameters +prarameter,parameter prarie,prairie praries,prairies prasied,praised prasies,praises pratcise,practise +pratical,practical +pratically,practically pratice,practice praticle,particle pratictioner,practitioners pratictioners,practitioners prceeded,preceded +prcess,process +prcesses,processes +prcessing,processing +prcoess,process +prcoessed,processed +prcoesses,processes +prcoessing,processing +prctiles,percentiles +prdpagate,propagate +prdpagated,propagated +prdpagates,propagates +prdpagating,propagating +prdpagation,propagation +prdpagations,propagations +prdpagator,propagator +prdpagators,propagators preadtor,predator preadtors,predators +preallocationg,preallocating +prealocate,preallocate +prealocated,preallocated +prealocates,preallocates +prealocating,preallocating +preambule,preamble preamde,premade +preamle,preamble preample,preamble +preaorocessing,preprocessing +preapared,prepared +preapre,prepare +preaprooved,preapproved +prebious,previous +precacheed,precached precaucion,precaution precausion,precaution precausions,precautions precautios,precautions +precceding,preceding +precding,preceding +preced,precede precedance,precedence precedeed,preceded precedense,precedence precedessor,predecessor precedessors,predecessors -preceed,precede -preceeded,preceded -preceeding,preceding -preceeds,precedes +preceds,precedes +preceed,precede,proceed +preceeded,preceded,proceeded +preceeding,preceding,proceeding +preceeds,precedes,proceeds +preceision,precision preceived,perceived +precence,presence +precendance,precedence +precendances,precedences +precende,precedence precendece,precedence +precendeces,precedences precendence,precedence +precendences,precedences +precendencies,precedences +precendent,precedent +precendes,precedences +precending,preceding +precends,precedence +precenence,preference,precedence +precenences,preferences +precense,presence +precent,percent,prescient precentage,percentage precentages,percentages precentile,percentile +precentiles,percentiles +precessor,predecessor,processor precice,precise +precicion,precision +precidence,precedence +preciding,preceding,presiding preciesly,precisely preciselly,precisely precisie,precise +precisily,precisely +precisionn,precision +precisision,precision precisley,precisely precisly,precisely +precison,precision precisou,precious +precission,precision,percussion,precession +precize,precise +precomuted,precomputed preconceieved,preconceived preconceved,preconceived preconcieve,preconceived +preconditoner,preconditioner +preconditoners,preconditioners +precondtion,precondition +precondtioner,preconditioner +precondtioners,preconditioners +precondtionner,preconditioner +precondtionners,preconditioners +precondtions,preconditions +preconfiged,preconfigured preconveived,preconceived precrastination,procrastination -precuation,precautions +precsions,precisions +precuation,precautions,precaution precuations,precautions preculde,preclude +precumputed,precomputed precurors,precursor precurosr,precursor precurser,precursor @@ -19705,17 +36647,24 @@ predeccesors,predecessor predecence,precedence predecesor,predecessor predecesores,predecessor +predecesors,predecessors predecesser,predecessor predecessores,predecessors +predeclarnig,predeclaring predection,prediction predections,predictions predective,predictive +predefiend,predefined +predefiened,predefined +predefiined,predefined +predefineds,predefined predescesor,predecessors predescesors,predecessors predesessor,predecessors predesposed,predisposed predessecor,predecessor predessecors,predecessors +predessor,predecessor predetermiend,predetermined predetermind,predetermined predeterminded,predetermined @@ -19743,6 +36692,7 @@ predictious,predictions predictivo,prediction predictment,predicament predictons,predictions +predifined,predefined predisposte,predisposed preditermined,predetermined predjuice,prejudice @@ -19762,9 +36712,14 @@ preductive,predictive predujice,prejudice predujiced,prejudiced predujices,prejudices +preeceding,preceding +preemptable,preemptible +preesnt,present preests,presets prefarable,preferable prefarably,preferably +prefectches,prefetches +prefecth,prefetch prefection,perfection prefectly,perfectly preferabbly,preferably @@ -19775,8 +36730,12 @@ preferance,preference preferances,preferences preferantial,preferential preferas,prefers +prefere,prefer,preferred prefereble,preferable +preferecne,preference +preferecnes,preferences prefered,preferred +preferend,preferred,preference preferens,preferences preferenser,preferences preferentail,preferential @@ -19789,11 +36748,23 @@ preferible,preferable preferibly,preferably prefering,preferring preferis,prefers +prefernce,preference +prefernces,preferences +prefernec,preference prefernece,preferences +preferr,prefer +preferrable,preferable preferrably,preferably +preferrence,preference +preferrences,preferences preferrring,preferring preferrs,prefers prefessionalism,professionalism +prefetchs,prefetches +prefferable,preferable +prefferably,preferably +preffered,preferred +prefices,prefixes preformance,performance preformances,performances preformer,performer @@ -19825,6 +36796,7 @@ preisthood,priesthood preists,priests preivew,preview preivews,previews +preivous,previous prejeduced,prejudiced prejeduces,prejudices prejiduce,prejudice @@ -19844,6 +36816,7 @@ prelimanary,preliminary prelimenary,preliminary prelimiary,preliminary preliminarly,preliminary +prelimitary,preliminary premanent,permanent premanently,permanently prematuraly,prematurely @@ -19865,12 +36838,18 @@ premire,premier premissible,permissible premission,permission premissions,permissions +premit,permit premits,permits premius,premiums premonasterians,premonstratensians +premption,preemption +premptive,preemptive +premptively,preemptively premuim,premium premuims,premiums +preocess,process preocupation,preoccupation +preoperty,property preorded,preordered preorderd,preordered preorderded,preordered @@ -19880,11 +36859,18 @@ preordes,preorders preoxide,peroxide prepair,prepare prepaird,prepaid +prepaired,prepared +prepand,prepend preparacion,preparation preparato,preparation +preparetion,preparation +preparetions,preparations prepartion,preparation +prepartions,preparations prepatory,preparatory +prependet,prepended prependicular,perpendicular +prepented,prepended preperation,preparation preperations,preparations prepetrated,perpetrated @@ -19895,24 +36881,46 @@ prepetuate,perpetuate prepetuated,perpetuated prepetuates,perpetuates prepetuating,perpetuating +preponderence,preponderance preporation,preparation preposterious,preposterous preposters,preposterous preposterus,preposterous prepostorous,preposterous preposturous,preposterous +preppend,prepend +preppended,prepended +preppendet,prepended +preppent,prepend,preprent +preppented,prepended +prepresent,represent +prepresented,represented +prepresents,represents +preproces,preprocess +preprocesing,preprocessing +preprocesor,preprocessor +preprocesssing,preprocessing preqeuls,prequels +prequisites,prerequisites prequles,prequels prerequesit,prerequisite +prerequesites,prerequisites prerequisets,prerequisite +prerequisit,prerequisite prerequisities,prerequisite +prerequisits,prerequisites prerequiste,prerequisite prerequisties,prerequisite prerequistite,prerequisite prerequites,prerequisite +prerequsite,prerequisite +prerequsites,prerequisites preriod,period +preriodic,periodic prerogitive,prerogative prerogotive,prerogative +prersistent,persistent +presance,presence prescients,presidents prescirbed,prescribed prescirption,prescriptions @@ -19924,20 +36932,33 @@ prescriped,prescribed prescriptionists,prescriptions prescripton,prescription prescriptons,prescriptions +prescrition,prescription +prescritions,prescriptions prescritpion,prescriptions presearing,preserving +presearvation,preservation +presearvations,preservations +presearve,preserve +presearved,preserved +presearver,preserver +presearves,preserves +presearving,preserving presecuted,persecuted presecution,persecution presedency,presidency presedential,presidential presedents,presidents presedintia,presidential +presenece,presence +presener,presenter presenning,presenting presens,presents presense,presence presenst,presets presentacion,presentation presentaion,presentation +presentaional,presentational +presentaions,presentations presentaiton,presentations presentas,presents presentase,presents @@ -19946,6 +36967,9 @@ presentato,presentation presentes,presents presention,presenting presentors,presents +presernt,present +preserrved,preserved +preserv,preserve preservacion,preservation preservare,preserve preservating,preservation @@ -19955,6 +36979,13 @@ preservaton,preservation preserverd,preserved preservered,preserved presest,presets +presetation,presentation +preseve,preserve +preseved,preserved +preseverance,perseverance +preseverence,perseverance +preseves,preserves +preseving,preserving presicely,precisely presicion,precision presidancy,presidency @@ -19971,13 +37002,25 @@ presideny,presidency presidet,presidents presidunce,presidency presist,persist +presistable,persistable +presistance,persistence +presistant,persistent +presistantly,persistently +presisted,persisted presistence,persistence +presistency,persistency presistent,persistent +presistently,persistently +presisting,persisting +presistion,precision presists,persists presitge,prestige presitgious,prestigious presitigous,prestigious +presmissions,permissions presnetation,presentations +presntation,presentation +presntations,presentations presomption,presumption presonalized,personalized presonally,personally @@ -19986,6 +37029,13 @@ presonhood,personhood prespective,perspective prespectives,perspectives presrciption,prescriptions +presreved,preserved +presse,pressed,press +pressent,present +pressentation,presentation +pressented,presented +pressre,pressure +presss,press,presses pressuming,pressuring pressureing,pressuring prestegious,prestigious @@ -20009,7 +37059,9 @@ presuasive,persuasive presude,presumed presumabely,presumably presumabley,presumably +presumaby,presumably presumebly,presumably +presumely,presumably presumendo,presumed presumibly,presumably presumpteous,presumptuous @@ -20025,6 +37077,7 @@ pretection,protection pretedermined,predetermined pretencious,pretentious pretendas,pretends +pretendend,pretended pretendendo,pretended pretendias,pretends pretene,pretense @@ -20041,10 +37094,18 @@ prevalecen,prevalence prevalente,prevalence prevantative,preventative preveiw,preview +preveiwed,previewed +preveiwer,previewer +preveiwers,previewers +preveiwes,previews,previewers preveiws,previews +prevelance,prevalence prevelant,prevalent +preven,prevent prevencion,prevention +prevend,prevent preventation,presentation +prevente,prevented,prevent preventetive,preventative preventin,prevention preventitive,preventative @@ -20053,28 +37114,60 @@ preventivno,prevention preventivo,prevention preventors,prevents preverse,perverse +preverses,preserves prevert,pervert +preverve,preserve +prevew,preview +prevews,previews previal,prevail previaling,prevailing previes,previews +previious,previous +previlege,privilege previos,previous +previosly,previously +previosu,previous previosuly,previously +previou,previous previoulsy,previously +previouly,previously +previouse,previous +previousl,previously +previsouly,previously +previuous,previous +previus,previous previvous,previous previwes,previews +prevoius,previous prevolence,prevalence +prevous,previous +prevously,previously +prewview,preview +prexisting,preexisting +prexixed,prefixed prezidential,presidential +prfer,prefer +prferable,preferable +prferables,preferables +prference,preference +prferred,preferred +prgram,program priased,praised priases,praises +priave,private pricinpals,principals pricipal,principal priciple,principle +priciples,principles +pricision,precision priemere,premiere priestes,priests priesthod,priesthood priestood,priesthood primaires,primaries primairly,primarily +primaray,primary +primarely,primarily primarilly,primarily primaris,primaries primarliy,primarily @@ -20082,8 +37175,16 @@ primarly,primarily primative,primitive primatively,primitively primatives,primitives +primay,primary +primeter,perimeter +primitiv,primitive +primitve,primitive +primitves,primitives +primive,primitive primordal,primordial princepals,principals +princeple,principle +princeples,principles princesas,princess princeses,princess princesess,princesses @@ -20103,29 +37204,43 @@ principl,principals principlaity,principality principlas,principals principly,principally +princliple,principle +prind,print +prinf,print,printf,sprintf +pring,print,bring,ping,spring +pringing,printing,springing prinicipal,principal prinicpals,principals prinicple,principle prinicples,principles printerest,printers printes,printers +printting,printing prioratize,prioritize prioretize,prioritize prioritice,prioritize prioritie,prioritize prioritied,prioritize +prioritiy,priority prioritse,priorities prioroties,priorities priorotize,prioritize +priorty,priority priotities,priorities priotitize,prioritize +priotity,priority +prirority,priority prisitne,pristine pristen,pristine +priting,printing privalege,privilege privaleged,privileged privaleges,privileges privaticed,privatized privatizied,privatized +privaye,private +privcy,privacy +privde,provide privelaged,privileged privelages,privileges priveldges,privileges @@ -20139,10 +37254,18 @@ priveliged,privileged priveliges,privileges privelleges,privileges privetized,privatized +priviate,private +privide,provide +privided,provided +privides,provides +prividing,providing +priview,preview privilage,privilege privilaged,privileged privilages,privileges priviledge,privilege +priviledged,privileged +priviledges,privileges privilegde,privileges privilegeds,privileges privilegie,privilege @@ -20151,13 +37274,26 @@ privilegien,privilege privilegier,privilege privilegies,privilege privilegs,privileges +privilige,privilege priviliged,privileged priviliges,privileges +privious,previous +priviously,previously +privision,provision +privisional,provisional +privisions,provisions privitazed,privatized privitized,privatized privledge,privilege +privleges,privileges privte,private +prmitive,primitive +prmitives,primitives +prmopting,prompting +proable,probable +proably,probably proactivley,proactive +probabaly,probably probabe,probable probabilaty,probability probabiliste,probabilities @@ -20166,23 +37302,45 @@ probabilites,probabilities probabiliy,probability probabillity,probability probabilty,probability -probabily,probability +probabily,probability,probably probablies,probable probablistic,probabilistic probablly,probably probablybe,probable +probaby,probably +probalby,probably probalibity,probability probaly,probably +probbably,probably +probbailities,probabilities +probbaility,probability +probbaly,probably +probbed,probed +probblem,problem +probblems,problems +probblez,problem +probblezs,problems +probbly,probably probelm,problem probelmatic,problematic probelms,problems +probem,problem +proberly,properly +proberty,property,properly +problably,probably problamatic,problematic +proble,probe probleem,problem problemas,problems problematisch,problematic +probleme,problem +problemes,problems problemita,problematic problimatic,problematic +problme,problem +problmes,problems problomatic,problematic +probly,probably procalim,proclaim procalimed,proclaimed procastrinating,procrastinating @@ -20190,18 +37348,29 @@ procastrination,procrastination procative,proactive procceding,proceeding proccedings,proceedings +procceed,proceed +proccesor,processor +proccesors,processors proccess,process +proccessed,processed +proccesses,processes proccessing,processing +proccessor,processor +proccessors,processors +procecure,procedure +procecures,procedures procedding,proceeding proceddings,proceedings -procede,proceed -proceded,proceeded +procede,proceed,precede +proceded,proceeded,preceded proceder,procedure procederal,procedural -procedes,proceeds +procedes,proceeds,precedes procedger,procedure -proceding,proceeding +proceding,proceeding,preceding procedings,proceedings +procedre,procedure +procedres,procedures procedrual,procedural procedue,procedure procedureal,procedural @@ -20210,21 +37379,50 @@ procedurile,procedure proceededs,proceeds proceedes,proceeds proceedure,procedure +proceedures,procedures proceeed,proceed -procees,proceeds +proceeeded,proceeded +proceeeding,proceeding +proceeeds,proceeds +proceeedures,procedures +procees,proceeds,process +proceesed,processed proceesing,proceeding +proceesor,processor procelain,porcelain +procelains,porcelains +procentual,percentual proces,process procesd,proceeds -procesed,proceeds +procesed,proceeds,processed +proceses,processes procesess,processes +proceshandler,processhandler +procesing,processing +procesor,processor +processeed,processed +processees,processes processer,processor processesor,processors +processess,processes +processessing,processing processeurs,processes +processig,processing +processinf,processing +processore,processor processos,processors -processs,processes +processpr,processor +processs,processes,process +processsed,processed +processses,processes +processsing,processing processsor,processors processsors,processors +procesure,procedure +procesures,procedures +procide,provide +procided,provided +procides,provides proclaimation,proclamation proclam,proclaim proclamed,proclaimed @@ -20234,6 +37432,9 @@ proclaming,proclaiming procliam,proclaim procliamed,proclaimed proclomation,proclamation +procoess,process +procoessed,processed +procoessing,processing proconceived,preconceived procotol,protocol procotols,protocols @@ -20253,7 +37454,15 @@ procreatin,procreation procrestinating,procrastinating procrestination,procrastination procriation,procreation +proctect,protect +proctected,protected +proctecting,protecting +proctects,protects +procteted,protected +procude,produce +procuded,produced procudures,procedures +prodceding,proceeding prodcution,production prodcutions,productions prodcuts,products @@ -20262,13 +37471,17 @@ prodecure,procedure prodecures,procedures prodictions,productions prodominantly,predominantly +producable,producible +producables,producibles produccion,production +produceds,produces,produced produceras,produces producerats,producers produceres,produces producirse,producers produciton,production producitons,productions +producted,produced productie,productive productin,productions producting,production @@ -20281,13 +37494,25 @@ productivy,productivity producto,production productoin,productions productos,products +produkt,product produktion,production produktions,productions produktive,productive produly,proudly -produse,produces +produse,produces,produce +prodused,produced +produses,produces produtcion,productions -profesion,profusion +proejct,project +proejcted,projected +proejcting,projecting +proejction,projection +proeprties,properties +proeprty,property +proerties,properties +proerty,property,poetry +proessing,processing +profesion,profusion,profession profesions,profession profesisonal,professionals profesor,professor @@ -20321,6 +37546,7 @@ proffesed,professed proffesion,profession proffesional,professional proffesor,professor +proffessor,professor proficeint,proficient proficiancy,proficiency proficiant,proficient @@ -20344,33 +37570,117 @@ profitibality,profitability profitible,profitable profressions,progressions proftiable,profitable +profund,profound +profundly,profoundly +progagate,propagate +progagated,propagated +progagates,propagates +progagating,propagating +progagation,propagation +progagations,propagations +progagator,propagator +progagators,propagators +progam,program +progamability,programmability +progamable,programmable +progamatic,programmatic +progamatically,programmatically +progamed,programed +progamer,programer +progamers,programers +progaming,programing +progamm,program +progammability,programmability +progammable,programmable +progammatic,programmatic +progammatically,programmatically +progammed,programmed +progammer,programmer +progammers,programmers +progamming,programming +progamms,programs +progams,programs +progapate,propagate +progapated,propagated +progapates,propagates +progapating,propagating +progapation,propagation +progapations,propagations +progapator,propagator +progapators,propagators +progaramm,program +progarammability,programmability +progarammable,programmable +progarammatic,programmatic +progarammatically,programmatically +progarammed,programmed +progarammer,programmer +progarammers,programmers +progaramming,programming +progaramms,programs +progarm,program +progarmability,programmability +progarmable,programmable +progarmatic,programmatic +progarmatically,programmatically +progarmed,programmed +progarmer,programmer +progarmers,programmers +progarming,programming +progarms,programs +progate,propagate +progated,propagated +progates,propagates +progating,propagating +progation,propagation +progations,propagations progatonists,protagonists progerssion,progressions progerssive,progressives +progess,progress +progessbar,progressbar progessed,progressed +progesses,progresses +progessive,progressive +progessor,progressor +progesss,progress progidy,prodigy programable,programmable programas,programs +programatic,programmatic +programatically,programmatically programattically,programmatically +programd,programed programem,programme +programemer,programmer +programemers,programmers programes,programs +programm,program,programme programmar,programmer programmare,programmer programmars,programmers programmate,programme +programmaticaly,programmatically +programmd,programmed,programme +programmend,programmed +programmetically,programmatically programmets,programmers programmeur,programmer programmeurs,programmer +programmical,programmatical programmier,programmer +programmign,programming programmme,programme programmmed,programme programmmer,programme programms,programs prograstination,procrastination +progres,progress progresing,progressing progresion,progression progresison,progressions progresive,progressive +progresively,progressively progressers,progresses progressie,progressives progressief,progressive @@ -20396,14 +37706,17 @@ progresso,progression progressoin,progressions progresson,progression progressos,progresses -progresss,progresses +progresss,progresses,progress progresssing,progressing progresssion,progressions progresssive,progressives progressus,progresses progressvie,progressives -progrom,pogrom -progroms,pogroms +progrewss,progress +progrmae,program +progrom,pogrom,program +progroms,pogroms,programs +progrss,progress prohabition,prohibition prohibation,prohibition prohibicion,prohibition @@ -20422,11 +37735,21 @@ prohibitting,prohibiting prohibitus,prohibits prohibitve,prohibited prohibt,prohibit +prohibted,prohibited +prohibting,prohibiting +prohibts,prohibits prohobited,prohibited prohpecies,prophecies prohpecy,prophecy prohpet,prophet prohpets,prophets +proirity,priority +projct,project +projction,projection +projctions,projections +projctor,projector +projctors,projectors +projcts,projects projecitle,projectiles projecte,projectile projecticle,projectile @@ -20436,6 +37759,7 @@ projectiel,projectiles projecties,projectiles projectils,projectiles projectin,projection +projectio,projection projectives,projectiles projectles,projectiles projectlie,projectiles @@ -20446,6 +37770,9 @@ projektile,projectile projektion,projection prokrastination,procrastination prolateriat,proletariat +prolbems,problems +prolem,problem +prolems,problems proletariaat,proletariat proletariant,proletariat proletaricat,proletariat @@ -20473,15 +37800,24 @@ prominance,prominence prominant,prominent prominantely,prominently prominantly,prominently -prominately,prominently +prominately,prominently,predominately prominenty,prominently prominetly,prominently +promis,promise promiscious,promiscuous promiscous,promiscuous promiscuious,promiscuous promisculous,promiscuous promiscuos,promiscuous promiscus,promiscuous +promiss,promise +promisse,promise,promises,promised +promissed,promised +promisses,promises +promissing,promising +promixity,proximity +prommpt,prompt +prommpts,prompts promocional,promotional promose,promotes promoteurs,promotes @@ -20491,15 +37827,21 @@ promotionnal,promotional promots,promotes promotted,promoted promplty,promptly +promprted,prompted +promps,prompts promptes,prompts promptus,prompts prompty,promptly promsicuous,promiscuous +promt,prompt promtply,promptly promtps,prompts +promts,prompts +pronnounced,pronounced pronography,pornography pronomial,pronominal prononciation,pronunciation +pronouce,pronounce pronouced,pronounced pronouciation,pronunciation pronoucned,pronounced @@ -20512,6 +37854,7 @@ pronoune,pronounced pronounes,pronouns pronouning,pronouncing pronous,pronouns +pronunce,pronounce pronunciacion,pronunciation pronunciating,pronunciation pronunciato,pronunciation @@ -20519,30 +37862,89 @@ pronunciaton,pronunciation pronuncuation,pronunciation pronunication,pronunciation pronuntiation,pronunciation +proocecure,procedure +proocecures,procedures +proocedure,procedure +proocedures,procedures +proocess,process +proocessed,processed +proocesses,processes +proocessing,processing +proocol,protocol +proocols,protocols +prooduce,produce +prooduced,produced +prooduces,produces +prooduct,product +prooerties,properties +prooerty,property +prool,pool +prooof,proof +prooper,proper +prooperly,properly +prooperties,properties +prooperty,property +proose,propose +proosed,proposed +prooses,proposes proove,prove prooved,proved +prooven,proven +prooves,proves +prooving,proving +proovread,proofread +prooxies,proxies +prooxy,proxy propabilities,probabilities +propably,probably propagana,propaganda propaganada,propaganda +propage,propagate +propatagion,propagation +propator,propagator +propators,propagators +propbably,probably propechies,prophecies propechy,prophecy propehcy,prophecy propeht,prophet propehts,prophets +propely,properly propencity,propensity propenents,proponents +propeoperties,properties properies,properties properitary,proprietary properites,properties +properities,properties +properries,properties +properrt,property +properry,property,properly +properrys,properties propersity,propensity +propert,property +properteis,properties +propertery,property propertiary,proprietary +propertie,property,properties propertion,proportion propertional,proportional propertions,proportions +propertise,properties propertius,properties -propertly,property +propertly,property,properly +propertu,property +propertus,properties +propertys,properties +propertyst,properties +propery,property,properly propesterous,preposterous propeties,properties +propetry,property +propetrys,properties +propety,property +propetys,properties +propgated,propagated prophacies,prophecies prophacy,prophecy prophechies,prophecies @@ -20552,12 +37954,21 @@ prophey,prophecy prophocies,prophecies propiertary,proprietary propietary,proprietary +propigate,propagate +propigation,propagation +proplem,problem proplusion,propulsion +propmt,prompt propmted,prompted +propmter,prompter propmtly,promptly +propmts,prompts +propoagate,propagate propoganda,propaganda propogate,propagate +propogated,propagated propogates,propagates +propogating,propagating propogation,propagation propolsion,propulsion proponants,proponents @@ -20567,6 +37978,8 @@ proponentes,proponents proponet,proponents proporcion,proportion proporition,proposition +proporpotion,proportion +proporpotional,proportional proportianal,proportional proportianally,proportionally proportians,proportions @@ -20588,8 +38001,12 @@ propositon,proposition proposse,proposes proposte,propose proposterous,preposterous +propostion,proposition propostions,proportions -propotions,proportions +propotion,proportion,promotion +propotional,proportional,promotional +propotions,proportions,promotions +proppely,properly propper,proper propperly,properly propreitary,proprietary @@ -20601,6 +38018,17 @@ proprietery,proprietary proprietory,proprietary proprietry,proprietary propriotary,proprietary +proproable,probable +proproably,probably +proprogate,propagate +proprogated,propagated +proprogates,propagates +proprogating,propagating +proprogation,propagation +proprogations,propagations +proprogator,propagator +proprogators,propagators +proproties,properties proprotion,proportion proprotional,proportional proprotionally,proportionally @@ -20610,11 +38038,17 @@ propsective,prospective propsects,prospects propserity,prosperity propserous,prosperous +propt,prompt +propteries,properties +propterties,properties +propterty,property propulaios,propulsion propulsing,propulsion propulstion,propulsion propultion,propulsion propuslion,propulsion +propvider,provider +prority,priority proscratination,procrastination prosectued,prosecuted prosectuion,prosecution @@ -20625,6 +38059,8 @@ prosecuters,prosecutors prosecutie,prosecuted proseletyzing,proselytizing prosepct,prospect +prosess,process +prosessor,processor prosicuted,prosecuted prosicution,prosecution prosicutor,prosecutor @@ -20640,6 +38076,7 @@ prospertiy,prosperity prospettive,prospective prosphetic,prosthetic prosporous,prosperous +prosseses,processes,possesses prostehtic,prosthetic prosterity,prosperity prostethic,prosthetic @@ -20689,15 +38126,21 @@ protagonits,protagonists protagonsit,protagonists protals,portals protastant,protestant +protcol,protocol +protcool,protocol +protcools,protocols +protcted,protected proteccion,protection +protecion,protection proteciton,protections protecs,protects -protecte,protective +protecte,protective,protected,protect protectes,protects protectice,protective protectie,protective protectiei,protective protectings,protections +protectiv,protective protectoin,protections protectons,protectors protectoras,protectors @@ -20705,9 +38148,11 @@ protectores,protectors protectos,protectors protectron,protection protectrons,protections +protedcted,protected proteinas,proteins proteines,proteins protelariat,proletariat +protential,potential protess,protests protestans,protests protestantes,protestants @@ -20721,6 +38166,7 @@ protestents,protestants protestes,protests protestina,protestant protestos,protests +protext,protect protfolio,portfolio prothsetic,prosthetic protiens,proteins @@ -20728,13 +38174,17 @@ protines,proteins protistant,protestant protistants,protestants protocal,protocol +protocals,protocols protocl,protocol +protoco,protocol protocoles,protocols +protocoll,protocol protocolls,protocols protocolos,protocols protocool,protocol protoganist,protagonist protoganists,protagonists +protoge,protege protogonist,protagonist protohypes,prototypes protostant,protestant @@ -20744,7 +38194,12 @@ protototype,prototype prototpye,prototype prototpyes,prototypes prototye,prototype +prototyes,prototypes prototyps,prototypes +protoype,prototype +protoypes,prototypes +protoytpe,prototype +protoytpes,prototypes protrait,portrait protraits,portraits protray,portray @@ -20760,17 +38215,38 @@ prouldy,proudly prouncements,pronouncements provacative,provocative provacotive,provocative +provate,private,provide provded,provided +provder,provider +provdided,provided +provdidet,provided,provider,provident +provdie,provide +provdied,provided +provdies,provides +provding,providing +provedd,proved,provided provencial,provincial proverai,proverbial proveribal,proverbial provervial,proverbial provicative,provocative +provicde,provide +provicded,provided +provicdes,provides +provice,provide,province provicial,provincial +provid,provide,prove,proved,proves providance,providence providee,providence providencie,providence +providewd,provided +providfers,providers providince,providence +provids,provides,proves +providse,provides,provide +provie,provide,prove +provied,provide,provided,proved +provies,provides,proves provinciaal,provincial provinciae,province provincie,province @@ -20782,7 +38258,10 @@ provinical,provincial provinicial,provincial provintial,provincial provinvial,provincial +provisioing,provisioning provisiones,provisions +provisiong,provisioning +provisionging,provisioning provisios,provisions provisiosn,provision provisonal,provisional @@ -20792,17 +38271,42 @@ provocatief,provocative provocativley,provocative provocitive,provocative provocotive,provocative +provode,provide +provoding,providing provokative,provocative +provsioning,provisioning proximty,proximity +proyect,project,protect +proyected,projected,protected +proyecting,projecting,protecting +proyection,projection,protection +proyections,projections,protections +proyects,projects,protects +prozess,process +prpeparations,preparations +prpose,propose +prposed,proposed +prposer,proposer +prposers,proposers +prposes,proposes +prposiing,proposing +prrcision,precision +prrottypes,prototypes +prtinf,printf pruchase,purchase pruchased,purchased pruchases,purchases +prufe,proof prugatory,purgatory pruposefully,purposefully pruposely,purposely prusuit,pursuit +prviate,private pryamid,pyramid pryamids,pyramids +psace,space +psaces,spaces +psaswd,passwd pscyhed,psyched pscyhedelic,psychedelic pscyhiatric,psychiatric @@ -20816,8 +38320,11 @@ pscyhopath,psychopath pscyhopathic,psychopathic pscyhopaths,psychopaths pscyhotic,psychotic +pseude,pseudo pseudononymous,pseudonymous pseudonyn,pseudonym +pseudopoential,pseudopotential +pseudopoentials,pseudopotentials pshyciatric,psychiatric pshyciatrist,psychiatrist pshycological,psychological @@ -20833,7 +38340,19 @@ pshycotic,psychotic psichological,psychological psichologically,psychologically psichologist,psychologist +psitoin,position +psitoined,positioned +psitoins,positions +psot,post +psots,posts +psrameter,parameter +pssed,passed +pssibility,possibility +psudo,pseudo psuedo,pseudo +psuedolayer,pseudolayer +psuh,push +psychadelic,psychedelic psychaitric,psychiatric psychaitrist,psychiatrist psychaitrists,psychiatrists @@ -20883,45 +38402,98 @@ psycology,psychology psycothic,psychotic psyhic,psychic psysiological,physiological +ptd,pdf +ptherad,pthread +ptherads,pthreads +pthon,python +pthred,pthread +pthreds,pthreads ptiched,pitched pticher,pitcher ptichers,pitchers ptichfork,pitchfork ptichforks,pitchforks +ptorions,portions +ptrss,press puasing,pausing +pubilsh,publish +pubilshed,published pubilsher,publisher +pubilshers,publishers +pubilshing,publishing +pubish,publish +pubished,published pubisher,publisher +pubishers,publishers +pubishing,publishing +publc,public,pubic +publcation,publication +publcise,publicise +publcize,publicize publiaher,publisher +publically,publicly publicaly,publicly publicani,publication +publich,publish,public +publiched,published publicher,publisher +publichers,publishers +publiches,publishes +publiching,publishing publicitan,publication publiclly,publicly publicy,publicly +publihsed,published publihser,publisher publikation,publication +publised,published +publisehd,published publisehr,publisher +publisehrs,publishers publiser,publisher +publisers,publishers +publisged,published publisger,publisher +publisgers,publishers +publishd,published publisheed,published publisherr,publisher publishher,publisher publishor,publisher +publishr,publisher publishre,publisher +publishrs,publishers publissher,publisher publlisher,publisher +publsh,publish +publshed,published +publsher,publisher +publshers,publishers +publshing,publishing publsih,publish +publsihed,published publsiher,publisher +publsihers,publishers +publsihes,publishes +publsihing,publishing +publuc,public +publucation,publication +publush,publish publusher,publisher +publushers,publishers +publushes,publishes +publushing,publishing puchasing,purchasing pucini,puccini puhsups,pushups puinsher,punisher pulisher,publisher +puls,pulse,plus pumkin,pumpkin pumkpins,pumpkins pumpinks,pumpkins pumpknis,pumpkins +punctation,punctuation punctiation,punctuation puncutation,punctuation punihsment,punishments @@ -20938,15 +38510,25 @@ punsihable,punishable punsiher,punisher punsihes,punishes punsihments,punishments +puplar,popular +puplarity,popularity +puplate,populate +puplated,populated +puplates,populates +puplating,populating +puplation,population puplications,publications puplisher,publisher +pupulated,populated puragtory,purgatory +purcahed,purchased purcahse,purchase purcahsed,purchased purcahses,purchases purchacing,purchasing purchaseing,purchasing purchashing,purchasing +purgest,purges purhcased,purchased puritannical,puritanical purpendicular,perpendicular @@ -20958,21 +38540,33 @@ purposefuly,purposefully purposelly,purposely purposley,purposely purpotedly,purportedly +purpse,purpose purpusefully,purposefully pursiut,pursuit +pursuade,persuade pursuaded,persuaded pursuades,persuades pursude,pursued purused,pursued +pusehd,pushed pushpus,pushups pususading,persuading puting,putting pwoer,power +pxoxied,proxied +pxoxies,proxies +pxoxy,proxy pyarmid,pyramid +pyhon,python +pyhsical,physical +pyhthon,python +pyhton,python pyramidas,pyramids +pyramide,pyramid pyramides,pyramids pyramind,pyramid pyramis,pyramids +pyrhon,python pyrimads,pyramids pyrmaid,pyramid pyrmaids,pyramids @@ -20993,6 +38587,12 @@ pyschopaths,psychopaths pyschosis,psychosis pyschotic,psychotic pyscic,psychic +pythin,python +pythjon,python +pytnon,python +pytohn,python +pyton,python +pytyon,python qaulification,qualification qaulifications,qualification qaulifiers,qualifiers @@ -21002,11 +38602,23 @@ qaulity,quality qauntity,quantity qauntum,quantum qaurterback,quarterback -qtuie,quite +qeueue,queue +qith,with +qoute,quote +qouted,quoted +qoutes,quotes +qouting,quoting +qtuie,quite,quiet +quadddec,quaddec +quadranle,quadrangle quailfiers,qualifiers quailfy,qualify +quailified,qualified quailty,quality +qualfied,qualified qualfiiers,qualifiers +qualfy,qualify +qualifer,qualifier qualifiaction,qualification qualifiactions,qualification qualificaiton,qualifications @@ -21023,10 +38635,17 @@ qualifikation,qualification qualifires,qualifiers qualifiy,qualify qualifyers,qualifiers +qualitification,qualification +qualitifications,qualifications qualitying,qualifying qualtitative,quantitative quanitfy,quantify +quanitified,quantified quanitites,quantities +quanlification,qualification,quantification +quanlified,qualified,quantified +quanlifies,qualifies,quantifies +quanlify,qualify,quantify quantaties,quantities quantatitive,quantitative quantaty,quantity @@ -21047,45 +38666,84 @@ quarantena,quarantine quarantene,quarantine quarantenni,quarantine quarantied,quarantine +quarentine,quarantine quarintine,quarantine quarterbackers,quarterbacks quarterblack,quarterback quartercask,quarterbacks quartery,quarterly +quartically,quadratically quartlery,quarterly quaruntine,quarantine +quatation,quotation +quater,quarter +quating,quoting,squatting qucikest,quickest +quckstarter,quickstarter +qudrangles,quadrangles queation,equation queations,equations +quee,queue queenland,queensland +queing,queuing queires,queries +queiried,queried +queisce,quiesce queitly,quietly quention,quentin quereis,queries +queriable,queryable +quering,querying +querries,queries +queryies,queries +queryinterace,queryinterface +querys,queries +quesiton,question quesitonable,questionable quesitoned,questioned quesitoning,questioning +quesitons,questions +questionaire,questionnaire questional,questionable questionalbe,questionable questionalble,questionable questiond,questioned questiong,questioning questionn,questioning +questionnair,questionnaire questionne,questioned questionned,questioned questionning,questioning questionsign,questioning +questoin,question +questoins,questions questonable,questionable +queu,queue +queueud,queued +queus,queues +quew,queue quicket,quickest quickets,quickest +quickier,quicker quicklyu,quickly +quicly,quickly quielty,quietly +quiessent,quiescent quinessential,quintessential -quitely,quietly +quitely,quietly,quite +quith,quit,with +quiting,quitting +quitt,quit +quitted,quit quizes,quizzes qunatum,quantum qunetin,quentin -qutie,quite +quotaion,quotation +quoteed,quoted +quottes,quotes +quried,queried +quroum,quorum +qutie,quite,quiet quuery,query rabbitos,rabbits rabbitts,rabbits @@ -21096,11 +38754,15 @@ racisst,racists racistas,racists racistes,racists racthet,ratchet +ractise,practise radaince,radiance radaint,radiant +radation,radiation +rade,read,raid radiactive,radioactive radiane,radiance radiaoctive,radioactive +radiaton,radiation radicalis,radicals radicas,radicals radiers,raiders @@ -21110,7 +38772,14 @@ radioactice,radioactive radioactief,radioactive radioactieve,radioactive radioaktive,radioactive +radiobuttion,radiobutton radiocative,radioactive +radis,radix +rady,ready +raed,read +raeding,reading +raeds,reads +raedy,ready raelism,realism raelly,really rahpsody,rhapsody @@ -21121,8 +38790,13 @@ railraod,railroad railrod,railroad rainbos,rainbows rainbowers,rainbows +raisedd,raised +raison,reason,raisin +ralation,relation ramificaitons,ramifications +randmom,random randmoness,randomness +randomally,randomly randomes,randoms randomez,randomized randomns,randoms @@ -21134,15 +38808,42 @@ randumness,randomness raoches,roaches raoming,roaming raosting,roasting +raotat,rotate +raotate,rotate +raotated,rotated +raotates,rotates +raotating,rotating +raotation,rotation +raotations,rotations +raotats,rotates raphsody,rhapsody +raplace,replace +raplacing,replacing +rapresent,represent +rapresentation,representation +rapresented,represented +rapresenting,representing +rapresents,represents rapsberry,raspberry raptores,raptors raptros,raptors raputre,rapture +rarelly,rarely +rarified,rarefied +rasberry,raspberry rasbperry,raspberry +rasie,raise +rasied,raised +rasies,raises +rasiing,raising +rasing,raising +rasons,reasons raspberrry,raspberry raspbery,raspberry +raspoberry,raspberry +rathar,rather rathcet,ratchet +rathern,rather rationalizaiton,rationalization rationalizating,rationalization rationalizaton,rationalization @@ -21151,15 +38852,52 @@ rationallity,rationally rationaly,rationally rationel,rationale ratpure,rapture +rcall,recall +rceate,create +rceating,creating +rduce,reduce +reaaly,really +reaarange,rearrange +reaaranges,rearranges +reaasigned,reassigned +reacahable,reachable +reacahble,reachable reaccurring,recurring +reaceive,receive +reacheable,reachable +reacher,richer +reachs,reaches reacing,reaching reacll,recall reactionair,reactionary reactionairy,reactionary reactionnary,reactionary reactiony,reactionary +reactquire,reacquire +readabilty,readability +readble,readable +readby,read +readeable,readable +readed,read,readd,readded +reademe,readme +readiable,readable +readibility,readability +readible,readable +readius,radius +readly,readily,ready readmition,readmission +readnig,reading +readning,reading +readyness,readiness +reaeched,reached reagrds,regards +reaise,realise,realise,raise +reaktivate,reactivate +reaktivated,reactivated +realease,release +realeased,released +realeases,releases +realiable,reliable realibility,reliability realible,reliable realibly,reliably @@ -21174,7 +38912,26 @@ realiste,realise realisticaly,realistically realisticlly,realistically realistisch,realistic +realitime,realtime realitvely,relatively +realiy,really +reall,real,really +realling,really +reallize,realize +reallllly,really +reallocae,reallocate +reallocaes,reallocates +reallocaiing,reallocating +reallocaing,reallocating +reallocaion,reallocation +reallocaions,reallocations +reallocaite,reallocate +reallocaites,reallocates +reallocaiting,reallocating +reallocaition,reallocation +reallocaitions,reallocations +reallocaiton,reallocation +reallocaitons,reallocations realoded,reloaded realoding,reloading realsie,realise @@ -21182,74 +38939,214 @@ realsied,realised realsim,realism realsitic,realistic realtable,relatable +realted,related realtes,relates -realtion,relation -realtions,relations +realtion,relation,reaction +realtions,relations,reactions realtionships,relationships -realtive,relative +realtive,relative,reactive realtively,relatively realtives,relatives realtivity,relativity realy,really realyl,really +reamde,readme reamined,remained reamining,remaining reamins,remains +reampping,remapping,revamping +reander,render +reanme,rename +reanmed,renamed +reanmes,renames +reanming,renaming +reaon,reason +reaons,reasons reapired,repaired reapirs,repairs reaplugs,earplugs reaplying,replaying reaponsibilities,responsibilities reaponsibility,responsibility +reappeares,reappears +reapper,reappear +reappered,reappeared +reappering,reappearing +reaquire,reacquire,require +rearely,rarely +rearranable,rearrangeable +rearrane,rearrange +rearraned,rearranged +rearranement,rearrangement +rearranements,rearrangements +rearranent,rearrangement +rearranents,rearrangements +rearranes,rearranges +rearrang,rearrange +rearrangable,rearrangeable +rearrangaeble,rearrangeable +rearrangaelbe,rearrangeable +rearrangd,rearranged +rearrangde,rearranged +rearrangent,rearrangement +rearrangents,rearrangements +rearrangmeent,rearrangement +rearrangmeents,rearrangements +rearrangmenet,rearrangement +rearrangmenets,rearrangements +rearrangment,rearrangement +rearrangments,rearrangements +rearrangnig,rearranging +rearrangning,rearranging +rearrangs,rearranges +rearrangse,rearranges +rearrangt,rearrangement +rearrangte,rearrange +rearrangteable,rearrangeable +rearrangteables,rearrangeables +rearrangted,rearranged +rearrangtement,rearrangement +rearrangtements,rearrangements +rearrangtes,rearranges +rearrangting,rearranging +rearrangts,rearrangements +rearraning,rearranging +rearranment,rearrangement +rearranments,rearrangements +rearrant,rearrangement +rearrants,rearrangements reasearch,research +reasearcher,researcher +reasearchers,researchers reaserch,research reaserched,researched reasercher,researcher reaserchers,researchers reaserching,researching +reasnable,reasonable +reasoable,reasonable +reasonabily,reasonably reasonablely,reasonably reasonabley,reasonably reasonablly,reasonably reasonal,reasonably +reasonble,reasonable +reasonbly,reasonably +reasonnable,reasonable +reasonnably,reasonably +reassocition,reassociation +reasssign,reassign reassureing,reassuring reassurring,reassuring +reasy,ready,easy reatiler,retailer +reatime,realtime +reattachement,reattachment reaveled,revealed reaveling,revealing +reay,ready,really,ray +reayd,ready,read rebellios,rebellious rebellis,rebellious rebiulding,rebuilding rebllions,rebellions +reboto,reboot reboudning,rebounding reboudns,rebounds rebounce,rebound rebouncing,rebounding rebouns,rebounds rebuidling,rebuilding +rebuil,rebuild,rebuilt +rebuilded,rebuilt rebuildling,rebuilding rebuildt,rebuilt +rebuillt,rebuilt +rebuils,rebuilds +rebuilts,rebuilds,rebuilt,rebuild +rebuit,rebuilt +rebuld,rebuild +rebulding,rebuilding +rebulds,rebuilds +rebulid,rebuild rebuliding,rebuilding +rebulids,rebuilds rebulit,rebuilt rebuplic,republic rebuplican,republican rebuplicans,republicans +recahed,reached +recalcuated,recalculated +recalcution,recalculation recalim,reclaim recallection,recollection +recalulate,recalculate +recalulation,recalculation recations,creations reccomend,recommend reccomendations,recommendations reccomended,recommended reccomending,recommending reccommend,recommend +reccommendation,recommendation +reccommendations,recommendations reccommended,recommended reccommending,recommending +reccommends,recommends +recconecct,reconnect +recconeccted,reconnected +recconeccting,reconnecting +recconecction,reconnection +recconecctions,reconnections +recconeccts,reconnects +recconect,reconnect +recconected,reconnected +recconecting,reconnecting +recconection,reconnection +recconections,reconnections +recconects,reconnects +recconeect,reconnect +recconeected,reconnected +recconeecting,reconnecting +recconeection,reconnection +recconeections,reconnections +recconeects,reconnects +recconenct,reconnect +recconencted,reconnected +recconencting,reconnecting +recconenction,reconnection +recconenctions,reconnections +recconencts,reconnects +recconet,reconnect +recconeted,reconnected +recconeting,reconnecting +recconetion,reconnection +recconetions,reconnections +recconets,reconnects reccuring,recurring +reccursive,recursive +reccursively,recursively receeded,receded receeding,receding +receied,received +receieve,receive +receieved,received +receieves,receives +receieving,receiving +receipient,recipient +receipients,recipients receips,receipts +receiption,reception +receiveing,receiving +receiviing,receiving +recenet,recent +recenlty,recently +recenly,recently recepcionist,receptionist recepient,recipient recepients,recipients +recepion,reception +recepit,recipe,receipt recepits,receipts receptie,receptive receptionest,receptionist @@ -21259,6 +39156,12 @@ receptionst,receptionist receptoras,receptors receptores,receptors receptos,receptors +receve,receive +receved,received +receves,receives +recevie,receive +recevied,received +recevies,receives receving,receiving recgonise,recognise recgonised,recognised @@ -21268,8 +39171,11 @@ recgonize,recognize recgonized,recognized recgonizes,recognizes recgonizing,recognizing +rechable,reachable rechargable,rechargeable +recheability,reachability reched,reached +rechek,recheck recide,reside recided,resided recident,resident @@ -21284,12 +39190,15 @@ reciever,receiver recievers,receivers recieves,receives recieving,receiving +recievs,receives recipees,recipes recipeints,recipients recipets,recipes recipiant,recipient recipiants,recipients +recipie,recipe recipientes,recipients +recipies,recipes reciporcate,reciprocate reciporcated,reciprocate recipricate,reciprocate @@ -21297,61 +39206,147 @@ reciprocant,reciprocate reciproce,reciprocate reciprociate,reciprocate reciprocite,reciprocate +reciprocoal,reciprocal +reciprocoals,reciprocals reciprocrate,reciprocate recitfy,rectify +recive,receive recived,received recivership,receivership +recives,receives +reciving,receiving +reclaimation,reclamation reclami,reclaim recliam,reclaim reclutant,reluctant reclutantly,reluctantly +recnt,recent,recant,rent +recntly,recently recocnised,recognised +recod,record +recofig,reconfig recoginse,recognise recoginsed,recognised recoginze,recognize recoginzed,recognized recogise,recognise recogize,recognize +recogized,recognized +recogizes,recognizes +recogizing,recognizing +recogniced,recognised recognices,recognizes recognicing,recognizing recognie,recognizes +recogninse,recognise recognision,recognition recogniton,recognition +recognizeable,recognizable recognizible,recognizable recognzied,recognised recolleciton,recollection recomend,recommend +recomendations,recommendations recomended,recommended recomending,recommending recomends,recommends +recommad,recommend +recommaded,recommended +recommand,recommend recommandation,recommendation recommandations,recommendations recommande,recommend +recommanded,recommended recommandes,recommends recommanding,recommending recommands,recommends +recommd,recommend +recommdation,recommendation +recommded,recommended +recommdend,recommend +recommdended,recommended +recommdends,recommends +recommds,recommends recommed,recommend +recommedation,recommendation recommedations,recommendations recommeded,recommended +recommeding,recommending +recommeds,recommends recommendeds,recommends recommendes,recommends recommendors,recommends -recommened,recommend +recommened,recommend,recommended recommeneded,recommended recommennd,recommends recommens,recommends recommented,recommended recommenting,recommending recomments,recommends +recommmend,recommend +recommmended,recommended +recommmends,recommends +recommnd,recommend +recommnded,recommended +recommnds,recommends +recommned,recommend +recommneded,recommended +recommneds,recommends recommondation,recommendation recommondations,recommendations +recommpile,recompile +recommpiled,recompiled recompence,recompense +recomplie,recompile,recomply +recomput,recompute +recomputaion,recomputation +recompuute,recompute +recompuuted,recomputed +recompuutes,recomputes +recompuuting,recomputing reconaissance,reconnaissance reconcider,reconsider reconcilation,reconciliation reconcille,reconcile reconcilled,reconcile +recondifure,reconfigure +reconecct,reconnect +reconeccted,reconnected +reconeccting,reconnecting +reconecction,reconnection +reconecctions,reconnections +reconeccts,reconnects +reconect,reconnect +reconected,reconnected +reconecting,reconnecting +reconection,reconnection +reconections,reconnections +reconects,reconnects +reconeect,reconnect +reconeected,reconnected +reconeecting,reconnecting +reconeection,reconnection +reconeections,reconnections +reconeects,reconnects reconenct,reconnect +reconencted,reconnected +reconencting,reconnecting +reconenction,reconnection +reconenctions,reconnections +reconencts,reconnects +reconet,reconnect +reconeted,reconnected +reconeting,reconnecting +reconetion,reconnection +reconetions,reconnections +reconets,reconnects +reconfifure,reconfigure +reconfiged,reconfigured +reconfugire,reconfigure +reconfugre,reconfigure +reconfugure,reconfigure +reconfure,reconfigure +recongifure,reconfigure recongise,recognise recongised,recognised recongition,recognition @@ -21360,24 +39355,46 @@ recongize,recognize recongized,recognized recongizes,recognizes recongizing,recognizing +recongnises,recognises +recongnizes,recognizes reconicle,reconcile reconisder,reconsider +reconize,recognize reconized,recognized reconnaisance,reconnaissance reconnaissence,reconnaissance reconnet,reconnect reconsidder,reconsider reconsiled,reconsider +reconstrcut,reconstruct +reconstrcuted,reconstructed +reconstrcution,reconstruction reconstruccion,reconstruction reconstrucion,reconstruction +reconstuct,reconstruct +reconstucted,reconstructed +reconstucting,reconstructing +reconstucts,reconstructs reconsturction,reconstruction recontructed,reconstructed +recontructing,reconstructing +recontruction,reconstruction +recontructions,reconstructions +recontructor,reconstructor +recontructors,reconstructors +recontructs,reconstructs recordare,recorder recordarle,recorder recordarme,recorder recordarse,recorder recordarte,recorder +recored,recorded +recoriding,recording recorre,recorder +recource,resource,recourse +recourced,resourced +recources,resources +recourcing,resourcing recoveres,recovers recoverys,recovers recoves,recovers @@ -21389,21 +39406,28 @@ recquired,required recrational,recreational recreacion,recreation recreacional,recreational +recreateation,recreation recreatie,recreate recreatief,recreate recreationnal,recreational recreativo,recreation recriational,recreational recrod,record +recrods,records recruitcs,recruits recruites,recruits +recrusevly,recursively recrusion,recursion +recrusive,recursive +recrusivelly,recursively +recrusively,recursively recrutied,recruited recrutier,recruiter recrutiers,recruiters recrutiment,recruitment rectange,rectangle rectangel,rectangle +rectanges,rectangles rectanglar,rectangular rectangluar,rectangular rectangual,rectangular @@ -21413,57 +39437,133 @@ rectangulaire,rectangular rectanlge,rectangle rectengular,rectangular rectifiy,rectify +rectiinear,rectilinear +recude,reduce recuiting,recruiting +reculrively,recursively recuring,recurring recurison,recursion +recurisvely,recursively recurited,recruited recuriter,recruiter recuriters,recruiters recuritment,recruitment recurits,recruits +recurively,recursively recurrance,recurrence +recursivelly,recursively +recursivion,recursion +recursivley,recursively recursivly,recursively +recusion,recursion,reclusion +recusive,recursive,reclusive +recusively,recursively,reclusively recusrion,recursion +recusrive,recursive +recusrsive,recursive +recustion,recursion +recyclying,recycling +recylcing,recycling +recyle,recycle +recyled,recycled +recyles,recycles +recyling,recycling +redandant,redundant +redction,reduction,redaction +redeable,readable +redeclaation,redeclaration redeemd,redeemed redeemeed,redeemed +redefiend,redefined +redefiende,redefined redefinied,redefine redefinine,redefine +redefintion,redefinition +redefintions,redefinitions redeisgn,redesign redemeed,redeemed redemtpion,redemption +redenderer,renderer redepmtion,redemption +redered,rendered redesgin,redesign redesiging,redesign redesing,redesign +redict,redirect rediculous,ridiculous +redidual,residual +redifinition,redefinition +redifintion,redefinition +redifintions,redefinitions +redircet,redirect +redirectd,redirected +redirectrion,redirection +redisign,redesign +redistirbute,redistribute +redistirbuted,redistributed +redistirbutes,redistributes +redistirbuting,redistributing redistirbution,redistribution redistribucion,redistribution redistribuito,redistribution redistributin,redistribution redistributivo,redistribution redistrubition,redistribution +redliens,redlines redmeption,redemption redneckers,rednecks redneckese,rednecks redneckest,rednecks +rednerer,renderer redners,renders +redonly,readonly +redudancy,redundancy +redudant,redundant +redunancy,redundancy +redunant,redundant reduncancy,redundancy +redundacy,redundancy redundantcy,redundancy redundany,redundancy +redundat,redundant redundency,redundancy redundent,redundant redundnacy,redundancy redunduncy,redundancy +reduntancy,redundancy +reduntant,redundant +reduse,reduce,reuse +redy,ready,red reedemed,redeemed reedeming,redeeming +reelation,relation +reelease,release +reename,rename reencarnation,reincarnation +reesrved,reserved +reesult,result reevalulate,reevaluate reevalutate,reevaluate +reevalute,reevaluate reevaulate,reevaluate reevaulated,reevaluate +reevaulating,reevaluating +refartor,refactor,refractor +refartored,refactored,refracted +refartoring,refactoring,refractoring +refcound,refcount +refcounf,refcount refect,reflect +refected,reflected +refecting,reflecting +refectiv,reflective +refector,refactor +refectoring,refactoring +refects,reflects refedendum,referendum refeeres,referees +refeinement,refinement +refeinements,refinements refelct,reflect refelcted,reflected refelcting,reflecting @@ -21471,33 +39571,62 @@ refelction,reflection refelctions,reflections refelctive,reflective refelcts,reflects +refelects,reflects refelxes,reflexes +refence,reference +refences,references +refenence,reference +refenrenced,referenced referal,referral referances,references referancing,referencing referandum,referendum +referant,referent +refere,refer,referee +referebces,references +referece,reference +referecence,reference +referecences,references refereces,references +referecne,reference refered,referred referede,referee refereees,referees refereers,referees +referefences,references referemce,reference referemces,references referemdum,referendum +referenace,reference +referenc,reference referenceing,referencing +referencial,referential +referencially,referentially referencs,references +referenct,referenced referendim,referendum referendom,referendum -referene,referee +referene,referee,reference referenece,reference refereneced,referenced refereneces,references +referenence,reference +referenenced,referenced +referenences,references +referenes,references referening,referencing referens,references -referense,references -referenses,referees +referense,references,reference +referensed,referenced +referenses,referees,references referentes,references +referenz,reference +referenzes,references +refererd,referred referere,referee +refererence,reference +referers,referrer,referrers +referes,refers,referees referiang,referring referig,referring referign,referring @@ -21505,20 +39634,45 @@ referincing,referencing refering,referring referinng,referring refernce,reference +refernced,referenced +referncence,reference +referncences,references refernces,references +referncial,referential +referncing,referencing refernece,reference +referneced,referenced referneces,references +refernnce,reference +referr,refer referrence,reference +referrenced,referenced referrences,references +referrencing,referencing +referreres,referrers +referres,refers referrs,refers refershed,refreshed refersher,refresher +refertence,reference +refertenced,referenced +refertences,references referundum,referendum +refesh,refresh +refeshed,refreshed +refeshes,refreshes +refeshing,refreshing reffered,referred refference,reference +refferes,refers,referees reffering,referring +refferr,refer +reffers,refers refilles,refills refillls,refills +refinemenet,refinement +refinmenet,refinement +refinment,refinement refirgerator,refrigerator refleciton,reflections reflecte,reflective @@ -21529,12 +39683,24 @@ reflecto,reflection reflektion,reflection reflexs,reflexes reflextion,reflection +refocuss,refocus +refocussed,refocused +reformating,reformatting +reformattd,reformatted reformerad,reformed reformes,reforms +refreh,refresh refrehser,refresher refreing,referring refrence,reference +refrenced,referenced refrences,references +refrencing,referencing +refrerence,reference +refrerenced,referenced +refrerenceing,referencing +refrerences,references +refrerencial,referential refrers,refers refreshd,refreshed refreshener,refresher @@ -21547,45 +39713,97 @@ refrigerador,refrigerator refrigerar,refrigerator refrigerater,refrigerator refrigirator,refrigerator +refromatting,refomatting refromed,reformed refromist,reformist refroms,reforms +refrormatting,reformatting refrubished,refurbished refubrished,refurbished refurbised,refurbished refurbushed,refurbished +refure,refuse +refures,refuses refusla,refusal +regalar,regular +regalars,regulars regardes,regards +regardles,regardless +regardlesss,regardless +regaring,regarding +regarldess,regardless +regarless,regardless +regart,regard +regarted,regarded +regarting,regarding +regartless,regardless +regeister,register +regeistered,registered +regeistration,registration regenade,renegade regenarate,regenerate +regenarated,regenerated regenaration,regeneration regeneracion,regeneration regeneratin,regeneration regeneraton,regeneration regenere,regenerate +regenrated,regenerated +regenratet,regenerated +regenrating,regenerating +regenration,regeneration +regenrative,regenerative regerts,regrets +regession,regression +regestered,registered regestration,registration +regidstered,registered regiems,regimes regimet,regiment regionaal,regional regiones,regions +regiser,register +regisration,registration regisrty,registry +regist,register registartion,registration +registe,register registed,registered -registerd,registered +registeing,registering +registeration,registration +registerd,registered,registers registerdns,registers +registerered,registered registeres,registers +registeresd,registered registeries,registers registerred,registered +registert,registered registery,registry +registes,registers +registing,registering +registors,registers +registrain,registration registraion,registration +registraration,registration registrating,registration registrato,registration +registred,registered +registrer,register +registring,registering +registrs,registers registy,registry +regiter,register +regitered,registered +regitering,registering +regiters,registers regluar,regular regocnition,recognition +regon,region +regorded,recorded regresas,regress regreses,regress +regresion,regression regresives,regressive regresos,regress regresse,regressive @@ -21597,7 +39815,22 @@ regrest,regrets regrests,regress regretts,regrets regrigerator,refrigerator +regsion,region +regsions,regions +regsiter,register +regsitered,registered +regsitering,registering +regsiters,registers regsitry,registry +regster,register +regstered,registered +regstering,registering +regsters,registers +regstry,registry +regualar,regular +regualarly,regularly +regualator,regulator +regualr,regular regualrly,regularly regualrs,regulars regualte,regulate @@ -21606,20 +39839,45 @@ regualtion,regulations regualtions,regulations regualtor,regulator regualtors,regulators +reguardless,regardless +reguarldess,regardless +reguarlise,regularise +reguarliser,regulariser +reguarlize,regularize +reguarlizer,regularizer reguarly,regularly +reguator,regulator regulacion,regulation regulae,regulate +regulaer,regular regulaion,regulation regulalry,regularly regulament,regulate +regulamentation,regulation +regulamentations,regulations regulaotrs,regulators +regulaotry,regulatory regulares,regulars regularily,regularly regularing,regulating +regulariry,regularly regularis,regulars regularlas,regulars +regularlisation,regularisation +regularlise,regularise +regularlised,regularised +regularliser,regulariser +regularlises,regularises +regularlising,regularising +regularlization,regularization +regularlize,regularize +regularlized,regularized +regularlizer,regularizer +regularlizes,regularizes +regularlizing,regularizing +regularlly,regularly regularlos,regulars -regulary,regularly +regulary,regularly,regular regulas,regulars regulaters,regulators regulatin,regulations @@ -21632,14 +39890,23 @@ regulatories,regulators regulatorios,regulators regulatr,regulator regulats,regulators +regulax,regular +reguler,regular +regulr,regular regulsr,regulars +regultor,regulator +regultors,regulators +regultory,regulatory regurally,regularly +regurlarly,regularly +reguster,register rehabilitacion,rehabilitation rehabilitaion,rehabilitation rehabilitaiton,rehabilitation rehabilitatin,rehabilitation rehabilitaton,rehabilitation rehersal,rehearsal +rehersing,rehearsing rehtoric,rhetoric rehtorical,rhetorical reicarnation,reincarnation @@ -21649,6 +39916,24 @@ reigment,regiment reigmes,regimes reigonal,regional reigons,regions +reigster,register +reigstered,registered +reigstering,registering +reigsters,registers +reigstration,registration +reimplemenet,reimplement +reimplementaion,reimplementation +reimplementaions,reimplementations +reimplented,reimplemented +reimplents,reimplements +reimpliment,reimplement +reimplimenting,reimplementing +reimplmenet,reimplement +reimplment,reimplement +reimplmentation,reimplementation +reimplmented,reimplemented +reimplmenting,reimplementing +reimplments,reimplements reinassance,renaissance reincarantion,reincarnation reincatnation,reincarnation @@ -21658,6 +39943,9 @@ reinforcemnt,reinforcement reinforcemnts,reinforcements reinforcemt,reinforcement reinfornced,reinforced +reinitailise,reinitialise +reinitailised,reinitialised +reinitailize,reinitialize reinitalise,reinitialise reinitalised,reinitialised reinitalises,reinitialises @@ -21668,6 +39956,8 @@ reinitalize,reinitialize reinitalized,reinitialized reinitalizes,reinitializes reinitalizing,reinitializing +reinitilize,reinitialize +reinitilized,reinitialized reinkarnation,reincarnation reinstale,reinstalled reinstaled,reinstalled @@ -21676,43 +39966,78 @@ reinstallled,reinstalled reinstallling,reinstalling reinstallng,reinstalling reintarnation,reincarnation +reintepret,reinterpret +reintepreted,reinterpreted reisntall,reinstall reisntalled,reinstalled reisntalling,reinstalling +reister,register reitrement,retirement reitres,retires reivews,reviews +reivison,revision +rejplace,replace rekenton,renekton reknown,renown reknowned,renowned rekommendation,recommendation rektifications,certifications +rekursed,recursed +rekursion,recursion +rekursive,recursive rela,real +relaative,relative +relady,ready +relaease,release +relaese,release +relaesed,released +relaeses,releases +relaesing,releasing relagation,relaxation +relaged,related relaibility,reliability relaible,reliable relaibly,reliably +relaimed,reclaimed +relaion,relation relaise,realise relaised,realised relaitonship,relationships +relaive,relative relaly,really relaoded,reloaded relaoding,reloading relapes,relapse +relase,release +relased,released +relaser,releaser +relases,releases +relashionship,relationship +relashionships,relationships +relasing,releasing relaspe,relapse relasped,relapsed relatabe,relatable +relatated,related relatation,relaxation +relatd,related +relatdness,relatedness relateds,relates relatiate,retaliate relatiation,retaliation +relatib,relative,relatable +relatibe,relative +relatibely,relatively relatie,relative +relatievly,relatively relatin,relation relatinoship,relationships relationshits,relationships relationshp,relationships relationsship,relationships relatiopnship,relationship +relativ,relative +relativated,relative,relatively relativety,relativity relativily,relativity relativiser,relatives @@ -21724,6 +40049,7 @@ relativley,relatively relativly,relatively relativno,relation relativy,relativity +relavant,relevant relavation,relaxation relavence,relevance relavent,relevant @@ -21732,7 +40058,22 @@ relazation,relaxation relcaim,reclaim relcutant,reluctant relcutantly,reluctantly +releaase,release +releaased,released +relead,reload releagtion,relegation +releant,relevant,relent +releas,release +releasead,released +releasse,release +releated,related +releating,relating +releation,relation +releations,relations +releationship,relationship +releationships,relationships +releative,relative +relecant,relevant relected,reelected relegato,relegation relegetion,relegation @@ -21744,10 +40085,18 @@ relentlessely,relentlessly relentlessley,relentlessly relentlessy,relentlessly relentness,relentless +releoad,reload +relese,release +relesed,released releses,releases +reletive,relative +reletively,relatively reletnless,relentless +relevabt,relevant +relevane,relevant relevation,revelation relevations,revelations +releveant,relevant relevence,relevance relevent,relevant relexation,relegation @@ -21765,7 +40114,9 @@ reliabilty,reliability reliabily,reliability reliablely,reliably reliabley,reliably +reliablity,reliability reliased,realised +relie,rely,relies,really,relief relient,reliant religeous,religious religeously,religiously @@ -21776,24 +40127,60 @@ religiosly,religiously religiousy,religiously religous,religious religously,religiously +relinguish,relinquish +relinguishing,relinquishing relinqushment,relinquishment +relintquish,relinquish relitavely,relatively -relized,realized +relized,realized,realized +rellocates,reallocates,relocates +relly,really +reloade,reload +relocae,relocate +relocaes,relocates +relocaiing,relocating +relocaing,relocating +relocaion,relocation +relocaions,relocations +relocaite,relocate +relocaites,relocates +relocaiting,relocating +relocaition,relocation +relocaitions,relocations +relocaiton,relocation +relocaitons,relocations +relocateable,relocatable +reloccate,relocate +reloccated,relocated +reloccates,relocates relpacement,replacement relpase,relapse relpased,relapsed +relpy,reply +reltive,relative reluctanct,reluctant reluctanctly,reluctantly reluctanly,reluctantly reluctanty,reluctantly reluctently,reluctantly +relyable,reliable +relyably,reliably +relyed,relied +relyes,relies,realize,realise +relys,relies remaind,remained remainds,remains +remainer,remainder +remaines,remains remaing,remaining +remainging,remaining remainig,remaining +remainst,remains remakrs,remarks +remaning,remaining remannt,remnant remannts,remnants +remaping,remapping remarcably,remarkably remarkablely,remarkably remarkabley,remarkably @@ -21802,17 +40189,46 @@ remarkes,remarks remarkibly,remarkably remasterd,remastered remasterred,remastered +rembember,remember +rembembered,remembered +rembembering,remembering +rembembers,remembers +rember,remember remeber,remember +remebered,remembered +remebering,remembering +remebers,remembers remembed,remembered remembee,remembered +rememberable,memorable rememberance,remembrance rememberd,remembered rememberes,remembers remembrence,remembrance +rememeber,remember +rememebered,remembered +rememebering,remembering +rememebers,remembers rememebr,remember +rememebred,remembered rememebrs,remembers +rememember,remember +rememembered,remembered +rememembers,remembers +rememer,remember +rememered,remembered +rememers,remembers +rememor,remember +rememored,remembered +rememoring,remembering +rememors,remembers +rememver,remember remenant,remnant +remenber,remember remenicent,reminiscent +remian,remain +remiander,remainder,reminder +remianed,remained remianing,remaining remians,remains remifications,ramifications @@ -21821,7 +40237,9 @@ reminent,remnant reminescent,reminiscent remingotn,remington reminicient,reminiscent +remining,remaining reminiscant,reminiscent +reminiscense,reminiscence reminiscient,reminiscent reminiscint,reminiscent reminisent,reminiscent @@ -21831,9 +40249,24 @@ reminsicent,reminiscent remmeber,remember remmebered,remembered remmebers,remembers +remmove,remove remnans,remnants +remoce,remove +remontly,remotely +remoote,remote +remore,remote +remorted,reported remotelly,remotely remotley,remotely +removce,remove +removeable,removable +removefromat,removeformat +removeing,removing +removerd,removed +remved,removed +remvoe,remove +remvoed,removed +remvoved,removed renaiisance,renaissance renaiscance,renaissance renaissace,renaissance @@ -21842,20 +40275,237 @@ renaissanse,renaissance renaissence,renaissance renassaince,renaissance renassiance,renaissance +renderadble,renderable renderd,rendered +rendereing,rendering renderered,rendered -renderes,renders +rendererers,renderers +renderering,rendering +renderes,renders,renderers +renderning,rendering +renderr,render +renderring,rendering rendevous,rendezvous rendezous,rendezvous +rendired,rendered +rendirer,renderer +rendirers,renderers +rendiring,rendering reneagde,renegade -renedered,rende +renedered,rende,rendered renegae,renegade renegated,renegade +renegatiotiable,renegotiable +renegatiotiate,renegotiate +renegatiotiated,renegotiated +renegatiotiates,renegotiates +renegatiotiating,renegotiating +renegatiotiation,renegotiation +renegatiotiations,renegotiations +renegatiotiator,renegotiator +renegatiotiators,renegotiators renegerate,regenerate renegeration,regeneration +renegoable,renegotiable +renegoate,renegotiate +renegoated,renegotiated +renegoates,renegotiates +renegoatiable,renegotiable +renegoatiate,renegotiate +renegoatiated,renegotiated +renegoatiates,renegotiates +renegoatiating,renegotiating +renegoatiation,renegotiation +renegoatiations,renegotiations +renegoatiator,renegotiator +renegoatiators,renegotiators +renegoating,renegotiating +renegoation,renegotiation +renegoations,renegotiations +renegoator,renegotiator +renegoators,renegotiators +renegociable,renegotiable +renegociate,renegotiate +renegociated,renegotiated +renegociates,renegotiates +renegociating,renegotiating +renegociation,renegotiation +renegociations,renegotiations +renegociator,renegotiator +renegociators,renegotiators +renegogtiable,renegotiable +renegogtiate,renegotiate +renegogtiated,renegotiated +renegogtiates,renegotiates +renegogtiating,renegotiating +renegogtiation,renegotiation +renegogtiations,renegotiations +renegogtiator,renegotiator +renegogtiators,renegotiators +renegoitable,renegotiable +renegoitate,renegotiate +renegoitated,renegotiated +renegoitates,renegotiates +renegoitating,renegotiating +renegoitation,renegotiation +renegoitations,renegotiations +renegoitator,renegotiator +renegoitators,renegotiators +renegoptionsotiable,renegotiable +renegoptionsotiate,renegotiate +renegoptionsotiated,renegotiated +renegoptionsotiates,renegotiates +renegoptionsotiating,renegotiating +renegoptionsotiation,renegotiation +renegoptionsotiations,renegotiations +renegoptionsotiator,renegotiator +renegoptionsotiators,renegotiators +renegosiable,renegotiable +renegosiate,renegotiate +renegosiated,renegotiated +renegosiates,renegotiates +renegosiating,renegotiating +renegosiation,renegotiation +renegosiations,renegotiations +renegosiator,renegotiator +renegosiators,renegotiators +renegotable,renegotiable +renegotaiable,renegotiable +renegotaiate,renegotiate +renegotaiated,renegotiated +renegotaiates,renegotiates +renegotaiating,renegotiating +renegotaiation,renegotiation +renegotaiations,renegotiations +renegotaiator,renegotiator +renegotaiators,renegotiators +renegotaible,renegotiable +renegotaite,renegotiate +renegotaited,renegotiated +renegotaites,renegotiates +renegotaiting,renegotiating +renegotaition,renegotiation +renegotaitions,renegotiations +renegotaitor,renegotiator +renegotaitors,renegotiators +renegotate,renegotiate +renegotated,renegotiated +renegotates,renegotiates +renegotatiable,renegotiable +renegotatiate,renegotiate +renegotatiated,renegotiated +renegotatiates,renegotiates +renegotatiating,renegotiating +renegotatiation,renegotiation +renegotatiations,renegotiations +renegotatiator,renegotiator +renegotatiators,renegotiators +renegotatible,renegotiable +renegotatie,renegotiate +renegotatied,renegotiated +renegotaties,renegotiates +renegotating,renegotiating +renegotation,renegotiation +renegotations,renegotiations +renegotatior,renegotiator +renegotatiors,renegotiators +renegotator,renegotiator +renegotators,renegotiators +renegothiable,renegotiable +renegothiate,renegotiate +renegothiated,renegotiated +renegothiates,renegotiates +renegothiating,renegotiating +renegothiation,renegotiation +renegothiations,renegotiations +renegothiator,renegotiator +renegothiators,renegotiators +renegotible,renegotiable +renegoticable,renegotiable +renegoticate,renegotiate +renegoticated,renegotiated +renegoticates,renegotiates +renegoticating,renegotiating +renegotication,renegotiation +renegotications,renegotiations +renegoticator,renegotiator +renegoticators,renegotiators +renegotioable,renegotiable +renegotioate,renegotiate +renegotioated,renegotiated +renegotioates,renegotiates +renegotioating,renegotiating +renegotioation,renegotiation +renegotioations,renegotiations +renegotioator,renegotiator +renegotioators,renegotiators +renegotioble,renegotiable +renegotion,renegotiation +renegotionable,renegotiable +renegotionate,renegotiate +renegotionated,renegotiated +renegotionates,renegotiates +renegotionating,renegotiating +renegotionation,renegotiation +renegotionations,renegotiations +renegotionator,renegotiator +renegotionators,renegotiators +renegotions,renegotiations +renegotiotable,renegotiable +renegotiotate,renegotiate +renegotiotated,renegotiated +renegotiotates,renegotiates +renegotiotating,renegotiating +renegotiotation,renegotiation +renegotiotations,renegotiations +renegotiotator,renegotiator +renegotiotators,renegotiators +renegotiote,renegotiate +renegotioted,renegotiated +renegotiotes,renegotiates +renegotioting,renegotiating +renegotiotion,renegotiation +renegotiotions,renegotiations +renegotiotor,renegotiator +renegotiotors,renegotiators +renegotitable,renegotiable +renegotitae,renegotiate +renegotitaed,renegotiated +renegotitaes,renegotiates +renegotitaing,renegotiating +renegotitaion,renegotiation +renegotitaions,renegotiations +renegotitaor,renegotiator +renegotitaors,renegotiators +renegotitate,renegotiate +renegotitated,renegotiated +renegotitates,renegotiates +renegotitating,renegotiating +renegotitation,renegotiation +renegotitations,renegotiations +renegotitator,renegotiator +renegotitators,renegotiators +renegotite,renegotiate +renegotited,renegotiated +renegotites,renegotiates +renegotiting,renegotiating +renegotition,renegotiation +renegotitions,renegotiations +renegotitor,renegotiator +renegotitors,renegotiators +renegoziable,renegotiable +renegoziate,renegotiate +renegoziated,renegotiated +renegoziates,renegotiates +renegoziating,renegotiating +renegoziation,renegotiation +renegoziations,renegotiations +renegoziator,renegotiator +renegoziators,renegotiators renetkon,renekton renewabe,renewables renewabels,renewables +reneweal,renewal renewebles,renewables renewl,renewal reniassance,renaissance @@ -21869,22 +40519,58 @@ rennovating,renovating rennovation,renovation renoylds,reynolds renteris,renters +rentime,runtime rentors,renters rentres,renters renuion,reunion renweables,renewables renyolds,reynolds +reoccurrence,recurrence +reocurring,reoccurring,recurring +reoder,reorder +reomvable,removable +reomve,remove +reomved,removed +reomves,removes +reomving,removing +reopended,reopened +reoport,report +reopsitory,repository +reord,record +reorded,reorder +reorer,reorder reorganision,reorganisation +reorginised,reorganised +reorginized,reorganized +reosnable,reasonable +reosne,reason +reosurce,resource +reosurced,resourced +reosurces,resources +reosurcing,resourcing +reounded,rounded +reouted,routed,rerouted reowrked,reworked +repace,replace +repaced,replaced +repacement,replacement +repacements,replacements +repaces,replaces +repacing,replacing +repackge,repackage +repackged,repackaged repaird,repaired repaires,repairs +repaitnt,repaint repalcement,replacement repalcements,replacements repalces,replaces repalying,replaying repalys,replays +repant,repaint,repent +repants,repaints,repents reparied,repaired -repatition,repetition +repatition,repetition,repartition repblic,republic repblican,republican repblicans,republicans @@ -21906,95 +40592,213 @@ repeates,repeats repeatetly,repeatedly repeatible,repeatable repeatidly,repeatedly -repectable,repeatable -repective,receptive +repeatly,repeatedly +repect,respect +repectable,repeatable,respectable +repected,respected +repecting,respecting +repective,receptive,respective repectively,respectively +repects,respects +repedability,repeatability +repedable,repeatable repeition,repetition repentable,repeatable repentence,repentance repentent,repentant +reperesent,represent +reperesentation,representation +reperesentational,representational +reperesentations,representations +reperesented,represented +reperesenting,representing +reperesents,represents repersentation,representation repersentations,representations repersented,represented repersenting,representing repersents,represents +repertoir,repertoire +repesent,represent +repesentation,representation +repesentational,representational +repesented,represented +repesenting,representing +repesents,represents +repet,repeat repetation,repetition +repetative,repetitive +repete,repeat repeteadly,repeatedly repetetion,repetition repeticion,repetition +repeting,repeating repetion,repetition +repetions,repetitions repetitivo,repetition +repetive,repetitive repharse,rephrase rephrasse,rephrase repid,rapid +repitition,repetition repitle,reptile repitles,reptiles +replaca,replica,replace +replacability,replaceability +replacable,replicable,replaceable +replacables,replaceables +replacacing,replacing +replacaiblity,replaceability,replicability +replacalbe,replaceable +replacalbes,replaceables +replacament,replacement +replacaments,replacements +replacas,replicas,replaces +replacate,replicate replacated,replicated +replacates,replicates +replacating,replicating +replacation,replication +replacd,replaced replaceble,replaceable +replaceemnt,replacement +replaceemnts,replacements +replacemenet,replacement replacemet,replacements replacemnet,replacements replacemnt,replacement replacemnts,replacements replacemtn,replacements -replase,replaces -replased,relapsed +replacmenet,replacement +replacment,replacement +replacments,replacements +replacong,replacing +replacte,replace,replicate +replacted,replaced,replicated +replactes,replaces,replicates +replacting,replacing,replicating +replaint,repaint +replase,replaces,replace,relapse,rephase +replased,relapsed,replaced,rephased +replasement,replacement +replasements,replacements +replases,replaces,relapses,rephases +replasing,replacing,relapsing,rephasing replayd,replayed replayes,replays +replcace,replace +replcaced,replaced +replcaof,replicaof repleacable,replaceable replecated,replicated -replicae,replicated +replicae,replicated,replicate +replicaes,replicates +replicaiing,replicating +replicaion,replication +replicaions,replications +replicaite,replicate +replicaites,replicates +replicaiting,replicating +replicaition,replication +replicaitions,replications +replicaiton,replication +replicaitons,replications +repling,replying replubic,republic replusive,repulsive +replys,replies repoistory,repository +reponding,responding reponse,response +reponses,responses +reponsibilities,responsibilities +reponsibility,responsibility reponsible,responsible reporduction,reproduction reporductive,reproductive +reporing,reporting +reporitory,repository reportadly,reportedly reportedy,reportedly reporteros,reporters reportes,reporters reportidly,reportedly +reportign,reporting +reportresouces,reportresources +reposiotory,repository repositary,repository +repositiories,repositories repositiory,repository +repositiroes,repositories +reposititioning,repositioning +repositorry,repository +repositry,repository reposity,repository +reposoitory,repository reposotory,repository repostas,reposts repostd,reposted repostes,reposts repostig,reposting +repostiories,repositories repostiory,repository repostus,reposts -reprecussion,repercussions +repote,report,remote +repport,report +repraesentation,representation +repraesentational,representational +repraesentations,representations +reprecussion,repercussions,repercussion +reprecussions,repercussions +repreesnt,represent +repreesnted,represented +repreesnts,represents reprehenisble,reprehensible reprehensable,reprehensible reprehinsible,reprehensible +reprensent,represent +reprensentation,representation +reprensentational,representational +reprensentations,representations +reprepresents,represents represantation,representation +represantational,representational represantations,representations represantative,representative represantatives,representatives +represenatation,representation +represenatational,representational +represenatations,representations represenation,representation -represend,represented +represenational,representational +represenations,representations +represend,represented,represent represensible,reprehensible representacion,representation representaciones,representations representaion,representation -representaiton,representations +representaional,representational +representaions,representations +representaiton,representations,representation representas,represents representate,representative +representated,represented representatie,representatives representatief,representative representatieve,representative representatin,representations -representating,representation +representating,representation,representing representationen,representations representationer,representations representativas,representatives representativo,representation +representd,represented +represente,represents,represented representerad,represented representes,represents representetive,representative representetives,representatives +representiative,representative represention,representing representitive,representative representitives,representatives @@ -22005,9 +40809,22 @@ representn,representing representstion,representations representstive,representatives represet,represents +represetation,representation represetnation,representations +represnet,represent represnetation,representations -repressent,represents +represneted,represented +represneting,representing +represnets,represents +represnt,represent +represntation,representation +represntative,representative +represnted,represented +represnts,represents +repressent,represents,represent +repressentation,representation +repressenting,representing +repressents,represents repressin,repression repressivo,repression represso,repression @@ -22016,15 +40833,42 @@ reprezentative,representative reprhase,rephrase repricussions,repercussions reprihensible,reprehensible +reprociblbe,reproducible +reprocible,reproducible +reprocuce,reproduce,reprocure +reprocuced,reproduced,reprocured +reprocuces,reproduces,reprocures +reprocucing,reproducing,reprocuring +reprodice,reproduce +reprodiced,reproduced +reprodicibility,reproducibility +reprodicible,reproducible +reprodicibly,reproducibly +reprodicing,reproducing +reprodiction,reproduction +reproducabely,reproducibly +reproducability,reproducibility reproducable,reproducible +reproducablitity,reproducibility +reproducably,reproducibly reproduccion,reproduction +reproduciblity,reproducibility reproducion,reproduction reproduciton,reproduction reproducive,reproductive reproducting,reproduction reproductivo,reproduction reproduktion,reproduction +reprot,report +reprots,reports +reprsent,represent +reprsentation,representation +reprsentations,representations +reprsented,represented +reprsenting,representing +reprsents,represents reprtoire,repertoire +reprucible,reproducible repsawn,respawn repsectable,respectable repsectful,respectful @@ -22038,6 +40882,7 @@ repsonded,responded repsonding,responding repsonds,responds repsonse,response +repsonses,responses repsonsibilities,responsibilities repsonsibility,responsibility repsonsible,responsible @@ -22045,6 +40890,8 @@ repsonsibly,responsibly repsonsive,responsive repsoted,reposted repsots,reposts +repspectively,respectively +repsresents,represents reptiel,reptile reptils,reptiles reptition,repetition @@ -22077,29 +40924,119 @@ repulisve,repulsive repulsie,repulsive repuslive,repulsive reputacion,reputation +reqest,request +reqested,requested +reqests,requests +reqeust,request +reqeusted,requested +reqeusting,requesting +reqeusts,requests +reqiest,request reqiuem,requiem +reqiure,require requeim,requiem +requeried,required requeriment,requirement requerimento,requirement requeriments,requirements +reques,request +requeset,request,requisite +requesr,request +requestd,requested +requestes,requests,requested +requestesd,requested +requestested,requested +requestests,requests,requested +requestied,requested +requestying,requesting +requeum,requiem +requied,required +requierd,required +requiere,require +requiered,required +requierement,requirement +requierements,requirements +requieres,requires +requiering,requiring requierment,requirements requierments,requirements requiers,requires +requies,requires +requiest,request +requiested,requested +requiesting,requesting +requiests,requests requieum,requiem requilme,requiem requime,requiem +requireing,requiring +requiremenet,requirement +requiremenets,requirements +requiremnt,requirement requirment,requirement +requirments,requirements +requisit,requisite +requisits,requisites +requre,require requred,required requrement,requirement +requres,requires +requrest,request +requrested,requested +requresting,requesting +requrests,requests requried,required requriements,requirements requries,requires +requriment,requirement +requring,requiring +requrired,required +requrirement,requirement +requrirements,requirements +requris,require +requsite,requisite +requsites,requisites +requst,request +requsted,requested +requsting,requesting +requsts,requests +reregisteration,reregistration +rererences,references +rerference,reference +rerferences,references +rerpesentation,representation +rertieves,retrieves +reruirement,requirement +reruirements,requirements +reruning,rerunning +rerurn,return,rerun +rerwite,rewrite resapwn,respawn +resarch,research +resart,restart +resarts,restarts resaurant,restaurant +resaurants,restaurants +rescaned,rescanned +rescource,resource +rescourced,resourced +rescources,resources +rescourcing,resourcing +rescrition,restriction +rescritions,restrictions rescuecd,rescued rescuse,rescues +reseach,research +reseached,researched researce,researcher researchs,researchers +researvation,reservation +researvations,reservations +researve,reserve +researved,reserved +researves,reserves +researving,reserving +reselction,reselection resembe,resemble resembelance,resemblance resembels,resembles @@ -22107,25 +41044,44 @@ resembes,resembles resemblace,resemble resemblence,resemblance resemblense,resembles +resently,recently +resepect,respect +resepected,respected +resepecting,respecting +resepective,respective +resepectively,respectively +resepects,respects reseptionist,receptionist reserach,research reserached,researched reseracher,researchers reserachers,researchers reseraching,researching +reseration,reservation reserrection,resurrection reserverad,reserved reserverd,reserved reservered,reserved +resest,reset,recessed +resestatus,resetstatus +resetable,resettable +reseted,reset +reseting,resetting +resetted,reset +reseved,reserved +reseverd,reserved resevoir,reservoir resgination,resignation resgined,resigned +resgister,register +resgisters,registers residencial,residential residentail,residential residental,residential residentual,residential residude,residue residule,residue +resierfs,reiserfs resignacion,resignation resignating,resignation resignement,resignment @@ -22156,39 +41112,92 @@ resistnace,resistances resistnaces,resistances resistribution,redistribution resitsance,resistances +resivwar,reservoir +resizeble,resizable +reslection,reselection reslove,resolve resloved,resolved resloves,resolves +resloving,resolving +reslut,result +resluts,results resmeble,resemble resmebles,resembles +resoect,respect +resoective,respective +resoiurce,resource +resoiurced,resourced +resoiurces,resources +resoiurcing,resourcing +resoltion,resolution resoltuion,resolutions resoltuions,resolutions resolucion,resolution +resoluitons,resolutions resolutin,resolutions resolutino,resolutions resolutionary,revolutionary resolutoin,resolutions +resoluton,resolution resolutons,resolutions resolvemos,resolves resolvendo,resolved resolveres,resolves resolverse,resolves +resolvinf,resolving resolviste,resolves resolvs,resolves +reson,reason resonabelt,resonate +resonable,reasonable resonet,resonate +resons,reasons +resonse,response +resonses,responses +resoource,resource +resoourced,resourced +resoources,resources +resoourcing,resourcing +resopnse,response +resopnses,responses +resorce,resource +resorced,resourced +resorces,resources +resorcing,resourcing +resore,restore +resoruce,resource +resoruced,resourced resoruces,resources +resorucing,resourcing resotration,restoration resotred,restored +resouce,resource +resouced,resourced +resouces,resources +resoucing,resourcing resoultion,resolution resoultions,resolutions +resourcd,resourced,resource +resourcde,resourced,resource +resourceype,resourcetype +resourcs,resources,resource +resourcse,resources,resource +resourcsed,resourced,resource +resoure,resource +resoured,resourced +resoures,resources resourse,resources +resoution,resolution +resoves,resolves resovle,resolve resovled,resolved resovles,resolves +respawining,respawning respecatble,respectable respecitve,respective respecitvely,respectively +respecive,respective +respecively,respectively respectabil,respectable respectabile,respectable respecte,respective @@ -22216,14 +41225,19 @@ respiratiory,respiratory respiratoy,respiratory respiritory,respiratory respitatory,respiratory +respnse,response +respnses,responses +respoduce,reproduce +responc,response,respond responce,response -responces,response +responces,response,responses responcibilities,responsibilities responcibility,responsibility responcible,responsible responcibly,responsibly responcive,responsive respondas,responds +responde,respond,response,responds,responded,responder respondendo,responded respondis,responds respondus,responds @@ -22237,6 +41251,7 @@ responisble,responsible responisbly,responsibly responisve,responsive responnsibilty,responsibility +respons,response,respond responsabile,responsible responsabilities,responsibilities responsability,responsibility @@ -22248,6 +41263,10 @@ responsbilty,responsibly responsbily,responsibly responsd,responds responsebilities,responsibilities +responsed,responded,responses +responser,responder +responsers,responders +responsess,responses responsibe,responsive responsibel,responsibly responsibil,responsibly @@ -22272,29 +41291,56 @@ responsile,responsive responsing,responding responsivle,responsive resporatory,respiratory +respose,response +resposes,responses +resposibility,responsibility +resposible,responsible +resposiblity,responsibility respositories,repositories respository,repository +resposive,responsive +resposiveness,responsiveness +resposne,response +resposnes,responses respoted,reposted respoting,reposting respriatory,respiratory respwan,respawn +resquest,request +resrouce,resource +resrouced,resourced +resrouces,resources +resroucing,resourcing +resrved,reserved +ressapee,recipe ressemblance,resemblance ressemble,resemble ressembled,resembled ressemblence,resemblance ressembling,resembling +ressemle,resemble +ressetting,resetting ressits,resists +ressize,resize +ressizes,resizes +ressource,resource +ressourced,resourced +ressources,resources +ressourcing,resourcing resssurecting,resurrecting +ressult,result ressurect,resurrect ressurected,resurrected +ressurecting,resurrecting ressurection,resurrection +ressurects,resurrects ressurrection,resurrection restanti,restarting restarant,restaurant restarants,restaurants restaraunt,restaurant -restaraunteur,restauranteur -restaraunteurs,restauranteurs +restaraunteur,restauranteur,restauranteur +restaraunteurs,restauranteurs,restauranteurs restaraunts,restaurants restaruant,restaurant restaruants,restaurants @@ -22306,31 +41352,47 @@ restauraunts,restaurants restaurent,restaurant restaurents,restaurants restauring,restarting +restaurnad,restaurant +restaurnat,restaurant resteraunt,restaurant resteraunts,restaurants +restes,reset +restesting,retesting resticted,restricted restircted,restricted restirction,restriction restirctions,restrictions restircts,restricts +restoding,restoring +restoiring,restoring +restor,restore restorani,restoration restorarion,restoration +restorated,restored restorating,restoration restord,restored +restoreable,restorable +restoreble,restorable +restoreing,restoring +restors,restores restorting,restarting +restouration,restoration restraind,restrained restraing,restraining restrainig,restraining restrainted,restrained restrainting,restraining restrait,restraint -restraunt,restraint +restraunt,restraint,restaurant restrcited,restricted restrcitions,restriction +restrcted,restricted restrcting,restarting +restrcuture,restructure restrective,restrictive restriant,restraint restriccion,restriction +restriced,restricted restricing,restricting restricion,restriction restricitng,restricting @@ -22354,22 +41416,55 @@ restrictons,restricts restriktion,restriction restriktive,restrictive restrittive,restrictive +restroing,restoring restructed,restricted restructing,restricting restruction,restriction restuarant,restaurant restuarants,restaurants +restucturing,restructuring resturant,restaurant resturants,restaurants resturaunt,restaurant resturaunts,restaurants +resturn,return +resturns,returns resuable,reusable +resubstituion,resubstitution resuced,rescued resuces,rescues +resuction,reduction +resue,reuse,rescue +resued,reused,rescued +resul,result +resuling,resulting +resulotion,resolution +resulsets,resultsets +resultion,resolution +resultions,resolutions +resultung,resulting +resulution,resolution +resumbmitting,resubmitting +resumitted,resubmitted +resumt,resume +resuorce,resource +resuorced,resourced +resuorces,resources +resuorcing,resourcing +resurce,resource +resurced,resourced +resurces,resources +resurcing,resourcing resurecting,resurrecting resurreccion,resurrection resurrecion,resurrection resurrektion,resurrection +resurse,recurse,resource +resursive,recursive,resourceful +resursively,recursively +resuse,reuse +resuts,results +resycn,resync retailate,retaliate retailation,retaliation retailes,retailers @@ -22379,31 +41474,94 @@ retalier,retailer retaliers,retailers retalitated,retaliated retalitation,retaliation +retangles,rectangles +retanslate,retranslate retardathon,retardation retardating,retardation retardatron,retardation retartation,retardation +retcieves,retrieves,receives reteriver,retriever +retet,reset,retest +retetting,resetting,retesting +rether,rather rethoric,rhetoric rethorical,rhetorical retierment,retirement +retieve,retrieve +retieved,retrieved +retieves,retrieves +retieving,retrieving +retinew,retinue retirase,retires retirbution,retribution retireds,retires retireus,retires retireve,retrieve retirever,retriever +retireving,retrieving +retirned,returned retoractively,retroactively +retore,restore +retored,restored +retores,restores +retoric,rhetoric +retorical,rhetorical +retoring,restoring +retourned,returned +retpresenting,representing +retquirement,requirement +retquirements,requirements +retquireseek,requireseek +retquiresgpos,requiresgpos +retquiresgsub,requiresgsub +retquiressl,requiressl +retranser,retransfer +retransferd,retransferred +retransfered,retransferred +retransfering,retransferring +retransferrd,retransferred +retransfert,retransfer,retransferred +retransmited,retransmitted +retransmition,retransmission retrebution,retribution +retreevable,retrievable +retreeval,retrieval +retreeve,retrieve +retreeved,retrieved +retreeves,retrieves +retreeving,retrieving +retreivable,retrievable +retreival,retrieval retreive,retrieve +retreived,retrieved +retreives,retrieves +retreiving,retrieving +retrevable,retrievable +retreval,retrieval +retreve,retrieve +retreved,retrieved +retreves,retrieves retrevier,retriever +retreving,retrieving retribucion,retribution retribuito,retribution retribuiton,retribution retributioon,retribution retributivo,retribution retribvtion,retribution +retrict,restrict +retricted,restricted +retriebe,retrieve +retriece,retrieve +retrieces,retrieves +retriev,retrieve +retrieveds,retrieved +retrival,retrieval,retrial +retrive,retrieve retrived,retrieved +retrives,retrieves +retriving,retrieving retroactivelly,retroactively retroactivily,retroactively retroactivley,retroactively @@ -22413,21 +41571,91 @@ retrocatively,retroactively retrosepct,retrospect retrospekt,retrospect retrubution,retribution +retrun,return +retruned,returned +retruns,returns +retsart,restart +retsarts,restarts +retun,return +retunr,return,retune retunred,returned +retunrned,returned +retunrs,returns retuns,returns +retur,return +reture,return +retured,returned +returend,returned +returing,returning +returm,return +returmed,returned +returming,returning +returms,returns returnd,returned +returnes,returns +returnig,returning +returnn,return +returnning,returning +returs,returns +retursn,returns +retutning,returning +retyring,retrying reuasble,reusable +reudce,reduce +reudced,reduced +reudces,reduces +reudction,reduction +reudctions,reductions +reuest,request +reuests,requests reuinon,reunion +reulator,regulator +reuplad,reupload +reupladad,reupload,reuploaded +reupladed,reuploaded +reuplader,reuploader +reupladers,reuploaders +reuplading,reuploading +reuplads,reuploads +reuplaod,reupload +reuplaodad,reupload,reuploaded +reuplaoded,reuploaded +reuplaoder,reuploader +reuplaoders,reuploaders +reuplaoding,reuploading +reuplaods,reuploads +reuplod,reupload +reuplodad,reupload,reuploaded +reuploded,reuploaded +reuploder,reuploader +reuploders,reuploaders +reuploding,reuploading +reuplods,reuploads reuptable,reputable +reuqest,request +reuqested,requested +reuqesting,requesting +reuqests,requests +reurn,return +reursively,recursively +reuslt,result +reussing,reusing +reutnred,returned +reutrn,return +reutrns,returns +revaildating,revalidating revaluated,reevaluated reveald,revealed reveales,reveals revealtion,revelations revealtions,revelations +reveive,receive,revive reveiw,review reveiwed,reviewed reveiwer,reviewer reveiwers,reviewers +reveiwes,reviews,reviewers +reveiwing,reviewing reveiws,reviews revelaed,revealed revelaing,revealing @@ -22438,27 +41666,51 @@ revelant,relevant revelas,reveals revelatons,revelations revelead,revealed +revelent,relevant revelution,revelation revelutionary,revolutionary -reveral,reversal +reveokes,revokes +rever,revert,refer,fever +reveral,reversal,referral reverals,reversal +reverce,reverse +reverced,reversed +reverece,reference,reverence +revereces,references +reverese,reverse +reveresed,reversed +reveret,revert +revereted,reverted reversable,reversible reversably,reversal +reverve,reserve +reverved,reserved +revewrse,reverse reviere,reviewer reviewd,reviewed reviewes,reviewers reviewr,reviewer +reviewsectio,reviewsection reviewtrue,reviewer revisiones,revisions revisionis,revisions +revisisions,revisions +revison,revision +revisons,revisions +reviwed,reviewed +reviwer,reviewer +reviwers,reviewers +reviwing,reviewing revlover,revolver revloves,revolves revolations,revolutions revoltuion,revolution +revoluion,revolution revoluiton,revolutions revolutin,revolutions revolutionair,revolutionary revolutionairy,revolutionary +revolutionar,revolutionary revolutionay,revolutionary revolutionens,revolutions revolutioners,revolutions @@ -22472,6 +41724,10 @@ revoultionary,revolutionary revoultions,revolutions revovler,revolver revovles,revolves +revrese,reverse +revrieve,retrieve +revrieves,retrieves +revsion,revision rewachted,rewatched rewarching,rewatching rewatchd,rewatched @@ -22479,17 +41735,30 @@ rewatchibg,rewatching rewatchig,rewatching rewatchign,rewatching rewatchimg,rewatching +rewirtable,rewritable rewirte,rewrite +rewirtten,rewritten +rewitable,rewritable +rewite,rewrite rewitten,rewritten reworkd,reworked +rewriable,rewritable,reliable rewriet,rewrite +rewriite,rewrite +rewrited,rewrote,rewritten +rewriten,rewritten rewritte,rewrite +rewritting,rewriting rewtched,wretched +rewuired,required reynlods,reynolds reynols,reynolds reyonlds,reynolds rezurrection,resurrection +rference,reference rferences,references +rfeturned,returned +rgister,register rhaposdy,rhapsody rhapsodomy,rhapsody rhapsoy,rhapsody @@ -22499,6 +41768,7 @@ rhetorisch,rhetoric rhymme,rhyme rhythem,rhythm rhythim,rhythm +rhythimcally,rhythmically rhytmic,rhythmic riaders,raiders rictatorship,dictatorship @@ -22523,9 +41793,10 @@ ridiculus,ridiculous rienforced,reenforced rienforcement,reinforcements rienforcements,reinforcements -rigeur,rigueur +rigeur,rigueur,rigour,rigour righetous,righteous righetousness,righteousness +righht,right righteos,righteous righteouness,righteousness righteoussness,righteousness @@ -22535,23 +41806,51 @@ rightiousness,righteousness rightoues,righteous rigntone,ringtone rigourous,rigorous +rigt,right +rigth,right rigtheous,righteous rigtheousness,righteousness rigthfully,rightfully +rigths,rights +rigurous,rigorous rilvaries,rivalries +riminder,reminder +riminders,reminders +riminding,reminding +rimitives,primitives ringotne,ringtone rininging,ringing -rised,raised +rised,raised,rose +rispective,respective +ristrict,restrict +ristricted,restricted +ristriction,restriction +ritable,writable ritalian,ritalin ritlain,ritalin ritoers,rioters rivalrly,rivalry rivarlies,rivalries rivarly,rivalry +rivised,revised rivlaries,rivalries rivlary,rivalry +rizes,rises +rlation,relation +rmeote,remote +rmeove,remove +rmeoved,removed +rmeoves,removes +rmove,remove +rmoved,removed +rmoving,removing +rnage,rage,range roachers,roaches roahces,roaches +roataion,rotation +roatation,rotation +roated,rotated +roation,rotation roaylties,royalties robberts,robbers robberys,robbers @@ -22560,13 +41859,22 @@ robocorp,robocop robocoup,robocop roboticus,robotics robotis,robotics +roboustness,robustness rockerfeller,rockefeller rococco,rococo rocord,record +roduce,reduce,produce +roduceer,producer roelplay,roleplay roestta,rosetta roganism,organism roganisms,organisms +roigin,origin +roiginal,original +roiginally,originally +roiginals,originals +roiginating,originating +roigins,origins roiters,rioters rolepaly,roleplay rolepalying,roleplaying @@ -22593,18 +41901,80 @@ romanmania,romanian romanna,romanian romanticaly,romantically roomate,roommate +ropeat,repeat +rorated,rotated rosettta,rosetta +rosponse,response +rosponsive,responsive rostaing,roasting +rotaion,rotation +rotaions,rotations +rotaiton,rotation +rotaitons,rotations +rotat,rotate +rotataion,rotation +rotataions,rotations +rotatd,rotated,rotate +rotatio,rotation,ratio +rotatios,rotations,ratios +rotats,rotates,rotate rotuers,routers +rouding,rounding +roughtly,roughly rougly,roughly +rouine,routine +rouines,routines roundabaout,roundabout roundaboot,roundabout roundabount,roundabout roundabounts,roundabout +roundign,rounding +roundtriped,roundtripped +roundtriping,roundtripping +roundtripp,roundtrip +rountine,routine +rountines,routines +rountrip,roundtrip +rountriped,roundtripped +rountriping,roundtripping +rountripped,roundtripped +rountripping,roundtripping routeros,routers +routet,routed,route,router +routin,routine,routing +routins,routines +rovide,provide +rovided,provided +rovider,provider +rovides,provides +roviding,providing royalites,royalties roylaties,royalties +rqeuest,request,quest +rqeuested,requested +rqeuesting,requesting +rqeuests,requests,quests +rquest,request,quest +rquested,requested +rquesting,requesting +rquests,requests,quests +rquire,require +rquired,required +rquirement,requirement +rquires,requires +rquiring,requiring +rranslation,translation +rranslations,translations +rrase,erase +rsizing,resizing,sizing +rsource,resource,source +rsourced,resourced,sourced +rsources,resources,sources +rsourcing,resourcing,sourcing +rturns,returns,turns +rubarb,rhubarb rucuperate,recuperate +rudimentally,rudimentary rudimentatry,rudimentary rudimentery,rudimentary rudimentory,rudimentary @@ -22614,10 +41984,24 @@ ruidmentary,rudimentary rulebok,rulebook ruleboook,rulebook rulle,rule +rumatic,rheumatic rumorus,rumors rumuors,rumors -runing,running +runing,running,ruining +runn,run +runned,ran,run,ruined +runnging,running,rummaging +runnig,running +runnign,running +runnigng,running +runnin,running +runnint,running +runnning,running +runns,runs runnung,running +runtine,runtime,routine +runting,runtime +rurrent,current ruslted,rustled russina,russian russion,russian @@ -22625,15 +42009,23 @@ rusteld,rustled rutgerus,rutgers rwite,write ryenolds,reynolds +rysnc,rsync rysurrection,resurrection rythem,rhythm rythim,rhythm rythm,rhythm rythmic,rhythmic rythyms,rhythms +saame,same +sabatage,sabotage +sabatour,saboteur +sacalar,scalar +sacalars,scalars +sacarin,saccharin sacarmento,sacramento sacarstic,sarcastic sacksonville,jacksonville +sacle,scale sacntioned,sanctioned sacntuary,sanctuary sacrafice,sacrifice @@ -22666,31 +42058,55 @@ sacrifising,sacrificing sacrifized,sacrificed sacrifizes,sacrifices sacrifizing,sacrificing +sacrifying,sacrificing +sacrilegeous,sacrilegious +sacrin,saccharin sacromento,sacramento saddends,saddens saddenes,saddens saddnes,saddens +sade,sad sadisitc,sadistic sadistc,sadistic sadistisch,sadistic sadning,sanding +saem,same +safeguared,safeguard,safeguarded +safeing,saving +safepooint,safepoint +safepooints,safepoints +safequard,safeguard +saferi,safari +safetly,safely +safly,safely saftey,safety safty,safety +sais,says saksatchewan,saskatchewan salaires,salaries salaris,salaries salavge,salvage +saleries,salaries salery,salary salughter,slaughter salughtered,slaughtered salughtering,slaughtering +salveof,slaveof salvery,slavery salying,slaying samckdown,smackdown +samll,small +samller,smaller +sammon,salmon +samori,samurai sampels,samples samruai,samurai samuari,samurai +samue,same,samuel samuria,samurai +samwich,sandwich +samwiches,sandwiches +sanaty,sanity sanctiond,sanctioned sanctionne,sanctioned sanctionned,sanctioned @@ -22702,6 +42118,7 @@ sandalls,sandals sandiwches,sandwiches sandlas,sandals sandnig,sanding +sandobx,sandbox sandstom,sandstorm sandstrom,sandstorm sandviches,sandwiches @@ -22709,16 +42126,28 @@ sandwhich,sandwich sandwishes,sandwiches sanhedrim,sanhedrin sanitazion,sanitation +sanitizisation,sanitization +sanizer,sanitizer sanlder,sandler sanotrum,santorum santcuary,sanctuary santiation,sanitation santioned,sanctioned +santize,sanitize +santized,sanitized +santizes,sanitizes +santizing,sanitizing santorm,santorum santourm,santorum santroum,santorum santurom,santorum +sanwich,sandwich +sanwiches,sandwiches +sanytise,sanitise +sanytize,sanitize sapcebar,spacebar +saphire,sapphire +saphires,sapphires sapphie,sapphire sapphirre,sapphire sapphrie,sapphire @@ -22732,6 +42161,7 @@ sarcasticlly,sarcastically sarcastisch,sarcastic sargant,sergeant sargeant,sergeant +sarting,starting,sorting sasauges,sausages sascatchewan,saskatchewan saskatcehwan,saskatchewan @@ -22746,20 +42176,29 @@ sasktachewan,saskatchewan sastified,satisfied sastifies,satisfies sastifying,satisfying +sastisfies,satisfies sasuage,sausage sasuages,sausages -sasy,says +sasy,says,sassy +satandard,standard +satandards,standards satasfaction,satisfaction satasfactory,satisfactory satelite,satellite satelites,satellites +satelitte,satellite satellie,satellites satellitte,satellites +satement,statement +satements,statements saterday,saturday saterdays,saturdays +satified,satisfied satifies,satisfies satifsy,satisfy satifsying,satisfying +satify,satisfy +satifying,satisfying satisfaccion,satisfaction satisfacion,satisfaction satisfacory,satisfactory @@ -22770,11 +42209,19 @@ satisfactorilly,satisfactory satisfactority,satisfactorily satisfactorly,satisfactory satisfcation,satisfaction +satisfiabilty,satisfiability satisfiction,satisfaction +satisfing,satisfying satisfiy,satisfy +satisfyied,satisfied satisifed,satisfied satisifes,satisfies +satisified,satisfied +satisifies,satisfies +satisify,satisfy +satisifying,satisfying satistactory,satisfactory +satistying,satisfying satisy,satisfy satric,satiric satrical,satirical @@ -22790,18 +42237,37 @@ satsifying,satisfying satsohi,satoshi sattelite,satellite sattelites,satellites +sattellite,satellite +sattellites,satellites +satuaday,saturday +satuadays,saturdays saturacion,saturation saturdsy,saturdays saught,sought +sav,save savanha,savanna savannh,savannah +savees,saves saveing,saving +savelt,svelte +savely,safely +savere,severe +savety,safety +savgroup,savegroup +savve,save,savvy,salve +savy,savvy sawnsea,swansea sawnson,swanson sawstika,swastika saxaphone,saxophone +sbsampling,subsampling scaepgoat,scapegoat +scahr,schar +scalarr,scalar +scaleability,scalability scaleable,scalable +scaleing,scaling +scalled,scaled scandales,scandals scandalos,scandals scandalosa,scandals @@ -22833,10 +42299,14 @@ scandivanian,scandinavian scandlas,scandals scandonavia,scandinavia scandonavian,scandinavian +scaned,scanned +scaning,scanning scannig,scanning scannign,scanning +scannning,scanning scantuary,sanctuary scaramento,sacramento +scarch,search,scorch,scratch scaricity,scarcity scarifice,sacrifice scarificed,sacrificed @@ -22849,18 +42319,56 @@ scartch,scratch scartched,scratched scartches,scratches scartching,scratching +scatch,catch,scratch,sketch +scatched,caught,scratched,sketched +scatcher,catcher,scratcher,sketcher +scatches,catches,scratches,sketches +scatching,catching,scratching,sketching +scatchs,catches,scratches,sketches +scatchss,catches,scratches,sketches scateboarding,skateboarding +scavange,scavenge scavanged,scavenged +scavanger,scavenger +scavangers,scavengers +scavanges,scavenges +sccope,scope +scecified,specified +sceen,scene,seen,screen,scheme +sceens,scenes,screens,schemes sceintific,scientific sceintifically,scientifically sceintist,scientist sceintists,scientists +sceme,scheme,scene +scemes,schemes,scenes scenarioes,scenarios +scenarion,scenario scenarions,scenarios scenarious,scenarios +scence,scene,science,sense +scences,scenes,sciences,senses,census +scenegraaph,scenegraph +scenegraaphs,scenegraphs +sceond,second +sceonds,seconds scepture,sceptre +scetch,sketch +scetched,sketched +scetches,sketches +scetching,sketching +schdule,schedule +schduled,scheduled +schduleing,scheduling +schduler,scheduler +schdules,schedules +schduling,scheduling schedual,schedule +scheduald,scheduled +schedualed,scheduled +schedualing,scheduling scheduleing,scheduling +schedulier,scheduler schedulling,scheduling scheems,schemes scheudling,scheduling @@ -22874,14 +42382,18 @@ schizophreniiic,schizophrenic schizophrentic,schizophrenic schizoprhenia,schizophrenia schizoprhenic,schizophrenic +schme,scheme +schmea,schema +schmeas,schemas +schmes,schemes schoalrs,scholars schoalrship,scholarships scholalry,scholarly scholarhip,scholarship -scholarhips,scholarship +scholarhips,scholarship,scholarships scholarhsips,scholarships scholarley,scholarly -scholarstic,scholastic +scholarstic,scholastic,scholarly scholary,scholarly scholership,scholarship scholerships,scholarships @@ -22889,6 +42401,7 @@ scholorship,scholarship scholorships,scholarships schoodle,schooled schoold,schooled +schould,should schozophrenia,schizophrenia schozophrenic,schizophrenic schyzophrenia,schizophrenia @@ -22900,29 +42413,56 @@ sciencists,scientists sciense,sciences scientests,scientists scientfic,scientific +scientfically,scientifically +scientficaly,scientifically +scientficly,scientifically scientic,scientific scientiests,scientists scientifc,scientific +scientifcally,scientifically +scientifcaly,scientifically +scientifcly,scientifically scientificaly,scientifically scientificlly,scientifically scientis,scientist +scientiss,scientist +scientisst,scientists,scientist scientits,scientist scince,science scinece,science +scintiallation,scintillation +scintillatqt,scintillaqt +scipt,script,skipped +scipted,scripted +scipting,scripting +scipts,scripts,skips +sciript,script +sciripts,scripts scirpt,script +scirpts,scripts scirptures,scriptures +scketch,sketch +scketched,sketched +scketches,sketches +scketching,sketching +sclar,scalar sclupture,sculpture scnadinavia,scandinavia scnadinavian,scandinavian +scneario,scenario scnearios,scenarios +scoket,socket scoll,scroll +scolling,scrolling scooterers,scooters scootes,scooters +scopeing,scoping scoprion,scorpion scorates,socrates scorebaord,scoreboard scoreboad,scoreboard scoreborad,scoreboard +scorebord,scoreboard scorebored,scoreboard scoripon,scorpion scorpin,scorpion @@ -22930,7 +42470,16 @@ scorpiomon,scorpion scorpoin,scorpion scostman,scotsman scottisch,scottish +scource,source,scouse +scourced,sourced,scoured +scourcer,scourer,sorcerer,scouser +scources,sources scpeter,scepter +scrach,scratch +scrached,scratched +scraches,scratches +scraching,scratching +scrachs,scratches scracth,scratch scracthed,scratched scracthes,scratches @@ -22939,44 +42488,87 @@ scrambe,scramble scrambeld,scrambled scrambleing,scrambling scramblies,scramble +scrao,scrap scratchs,scratches scrathces,scratches +screem,scream,screen +screenchot,screenshot +screenchots,screenshots screenshat,screenshot screenshit,screenshot screenshoot,screenshot screenshoots,screenshot screenwrighter,screenwriter +screnn,screen +scriopted,scripted +scriopting,scripting +scriopts,scripts +scriopttype,scripttype +scriping,scripting +scripst,scripts scriptores,scriptures scriptue,scriptures scripturae,scriptures scriptus,scripts +scriptype,scripttype scriputres,scriptures +scritp,script scritped,scripted +scritping,scripting scritps,scripts +scritpt,script +scritpts,scripts scritpures,scriptures scroates,socrates +scroipt,script +scroipted,scripted +scroipting,scripting +scroipts,scripts +scroipttype,scripttype +scrollablbe,scrollable scrollade,scrolled scrolld,scrolled +scrollin,scrolling +scroolbar,scrollbar scropion,scorpion scrpited,scripted scrpits,scripts +scrren,screen scruitny,scrutiny scrunity,scrutiny scrutiney,scrutiny scrutinity,scrutiny scrutinty,scrutiny +sction,section,suction +sctional,sectional,suctional +sctioned,sectioned,suctioned +sctioning,sectioning,suctioning +sctions,sections,suctions sctosman,scotsman -sculpter,sculpture +scubscribe,subscribe +scubscribed,subscribed +scubscriber,subscriber +scubscribes,subscribes +scuccessully,successfully +sculpter,sculpture,sculptor +sculpters,sculptors,sculptures sculpteur,sculpture sculputre,sculpture scultpure,sculpture scuplture,sculpture +scupt,sculpt +scupted,sculpted +scupting,sculpting +scupture,sculpture scuptures,sculptures scurtiny,scrutiny scyhter,scyther seach,search seached,searched seaches,searches +seaching,searching +seachkey,searchkey +seacrchable,searchable seahakws,seahawks seahawkers,seahawks seahaws,seahawks @@ -22985,22 +42577,57 @@ seamlessley,seamlessly seamlessy,seamlessly seantor,senator seantors,senators +searcahble,searchable searchd,searched +searche,search,searched +searcheable,searchable searchign,searching +searchin,searching searchs,searches +seatch,search sebasitan,sebastian sebastain,sebastian sebastiaan,sebastian sebastin,sebastian sebrian,serbian sebsatian,sebastian -secceeded,seceded -seceed,succeed -seceeded,succeeded +secceeded,seceded,succeeded +seccond,second +secconds,seconds +secction,section +seceed,succeed,secede +seceeded,succeeded,seceded +secene,scene secertary,secretary secertly,secretly secerts,secrets +secific,specific +secion,section +secions,sections +secirity,security +seciton,section +secitons,sections +secne,scene +secod,second +seconadry,secondary +seconcary,secondary +secondaray,secondary +seconday,secondary +secondy,secondly,secondary +seconf,second +seconly,secondly +secont,second +secontary,secondary +secontly,secondly +seconts,seconds +secord,second +secotr,sector +secound,second +secoundary,secondary +secoundly,secondly +secounds,seconds secpter,scepter +secquence,sequence secratary,secretary secratery,secretary secrelty,secretly @@ -23010,17 +42637,70 @@ secretery,secretary secretley,secretly secretos,secrets secrety,secretly +secrion,section secruity,security +sectin,section +sectins,sections +sectionis,sections +sectionning,sectioning +sectiont,sectioned,section +secton,section +sectoned,sectioned +sectoning,sectioning +sectons,sections +secue,secure +secuely,securely secuirty,security +secuity,security +secund,second +securiy,security +securiyt,security +securly,securely +securre,secure +securrely,securely +securrly,securely +securtity,security +securtiy,security +securty,security +securuity,security sedentarity,sedentary sedereal,sidereal sednetary,sedentary seduciton,seduction +seeem,seem +seeen,seen +seelect,select +seemes,seems +seemless,seamless +seemlessly,seamlessly +seesion,session +seesions,sessions +seeting,seating,setting,seething seflies,selfies seflishness,selfishness segegrated,segregated +segement,segment segementation,segmentation +segements,segments +segemnts,segments segergation,segregation +segfualt,segfault +segfualts,segfaults +segmantation,segmentation +segmend,segment +segmendation,segmentation +segmended,segmented +segmends,segments +segmenet,segment +segmenetd,segmented +segmeneted,segmented +segmenets,segments +segmentaion,segmentation +segmente,segment +segmentes,segments +segmetn,segment +segmetned,segmented +segmetns,segments segragated,segregated segragation,segregation segregacion,segregation @@ -23030,37 +42710,115 @@ segretated,segregated segretation,segregation segrigated,segregated segrigation,segregation +segument,segment seguoys,segues +seh,she seige,siege seing,seeing seinor,senior seinors,seniors +seires,series +sekect,select +sekected,selected +sekects,selects +selcetion,selection +selctable,selectable +selctables,selectables +selcted,selected +selcting,selecting +selction,selection +selctions,selections seldomly,seldom +seleced,selected +selecetd,selected +selecgt,select +selecgted,selected +selecgting,selecting +selecing,selecting +selectd,selected +selecte,selected,select +selectes,selects selectie,selective +selectin,selection,selecting selectiose,selections selectivley,selectively selectivly,selectively selectivos,selections +selectoin,selection +selecton,selection +selectons,selections +seledted,selected +selektions,selections +selektor,selector +seleted,selected,deleted +seletion,selection,deletion +seletions,selections,deletions selfeshness,selfishness selfiers,selfies selfishess,selfishness +selfs,self selifes,selfies +selt,set,self,sold +selv,self +semaintics,semantics semanitcs,semantics +semaphone,semaphore +semaphones,semaphores +semaphor,semaphore +semaphors,semaphores +semapthore,semaphore +semapthores,semaphores +sematic,semantic +sematical,semantical +sematically,semantically +sematics,semantics +sematnics,semantics +semding,sending +sement,cement,segment +sementation,segmentation +semented,cemented,segmented +sementing,cementing,segmenting +sements,cements,segments semestre,semester semestres,semesters +semgent,segment +semicolor,semicolon +semicolumn,semicolon +semicondutor,semiconductor semnatics,semantics +sempahore,semaphore +sempahores,semaphores +sempaphore,semaphore +sempaphores,semaphores +semphore,semaphore +semphores,semaphores +sempphore,semaphore semseter,semester semseters,semesters +senaphore,semaphore +senaphores,semaphores +senario,scenario senarios,scenarios senatores,senators -sence,sense +sence,sense,since +sencond,second +sencondary,secondary +senconds,seconds sendetary,sedentary +sendign,sending +sendinging,sending +sendinng,sending senerity,serenity +senfile,sendfile +senintels,sentinels seniores,seniors senisble,sensible senitmental,sentimental senitments,sentiments +senitnel,sentinel +senitnels,sentinels senoirs,seniors +senquence,sequence sensacional,sensational sensacionalism,sensationalism sensacionalist,sensationalist @@ -23082,31 +42840,45 @@ sensationilism,sensationalism sensationilist,sensationalist sensationnal,sensational sensationslism,sensationalism +sensative,sensitive sensetional,sensational sensetionalism,sensationalism sensibel,sensible sensibilisiert,sensibilities sensibilites,sensibilities +sensisble,sensible +sensistive,sensitive +sensistively,sensitively,sensitivity +sensitiv,sensitive +sensitiveties,sensitivities sensitivety,sensitivity sensitivitiy,sensitivity sensitiviy,sensitivity +sensitivties,sensitivities sensitivty,sensitivity -sensitivy,sensitivity +sensitivy,sensitivity,sensitively +sensitve,sensitive +sensivity,sensitivity,sensitively sensores,sensors senstive,sensitive sensure,censure sentamental,sentimental sentaments,sentiments +sentance,sentence +sentances,sentences sentancing,sentencing sentaor,senator sentaors,senators sentationalism,sensationalism sentationalist,sensationalist +senteces,sentences sentemental,sentimental sentements,sentiments sentenceing,sentencing sentencian,sentencing +sentense,sentence sentensing,sentencing +sentienl,sentinel sentiers,sentries sentimant,sentimental sentimenal,sentimental @@ -23114,87 +42886,336 @@ sentimentals,sentiments sentimentos,sentiments sentimentul,sentimental sentimetal,sentimental +sentinal,sentinel +sentinals,sentinels sentincing,sentencing sentinents,sentiments sentinet,sentient sentinte,sentient sentires,sentries +sentive,sensitive +sentively,sensitively,sensitivity +sentivite,sensitive sentreis,sentries sentris,sentries senzationalism,sensationalism senzationalist,sensationalist +seond,second,send +seonds,seconds,sends +sepaate,separate separacion,separation +separartor,separator +separat,separate separatedly,separately separatelly,separately +separater,separator separaters,separates separatisme,separates separatiste,separates separatley,separately +separatly,separately separato,separation separatron,separation +separed,separated separete,separate +separeted,separated +separetedly,separately separetely,separately +separeter,separator +separetes,separates +separeting,separating +separetly,separately +separetor,separator +separtates,separates +separte,separate +separted,separated +separtes,separates +separting,separating +sepatae,separate +sepatate,separate +sepcial,special sepcially,specially -sepcifications,specification +sepcific,specific +sepcifically,specifically +sepcification,specification +sepcifications,specification,specifications +sepcified,specified +sepcifier,specifier +sepcifies,specifies +sepcify,specify +sepcifying,specifying sepculating,speculating +sepearable,separable +sepearate,separate +sepearated,separated +sepearately,separately +sepearates,separates +sepearation,separation +sepearator,separator +sepearators,separators +sepearet,separate +sepearetly,separately sepearte,separate +sepearted,separated +sepeartely,separately +sepeartes,separates +sepeartor,separator +sepeartors,separators +sepeate,separate +sepeated,separated +sepeates,separates +sepeator,separator +sepeators,separators +sepecial,special +sepecially,especially,specially +sepecifed,specified +sepecific,specific +sepecification,specification +sepecified,specified +sepecifier,specifier +sepecifiers,specifiers +sepecifies,specifies +sepecify,specify +sepectral,spectral +sepeicfy,specify +sepend,depend,suspend +sependent,dependent +sepending,depending +seperable,separable +seperad,separate +seperadly,separately +seperaly,separately +seperaor,separator +seperaors,separators +seperare,separate +seperared,separated +seperares,separates +seperat,separate +seperataed,separated +seperatally,separately +seperataly,separately +seperatated,separated +seperatd,separated seperate,separate seperated,separated +seperatedly,separately +seperatedy,separated +seperateely,separately +seperateing,separating +seperatelly,separately seperately,separately +seperater,separator +seperaters,separators seperates,separates seperating,separating seperation,separation +seperations,separations seperatism,separatism seperatist,separatist seperatley,separately +seperatly,separately seperator,separator -sepina,subpena +seperators,separators +sepereate,separate +sepereated,separated +sepereates,separates +sepererate,separate +sepererated,separated +sepererates,separates +seperete,separate +sepereted,separated +seperetes,separates +seperratly,separately +sepertator,separator +sepertators,separators +sepertor,separator +sepertors,separators +sepetaror,separator +sepetarors,separators +sepetate,separate +sepetated,separated +sepetately,separately +sepetates,separates +sepina,subpena,subpena seplling,spelling +seporate,separate +sepperate,separate +seprarate,separate +seprate,separate +seprated,separated +seprator,separator +seprators,separators sepreate,separate +septemer,september septmeber,september -sepulchure,sepulchre -sepulcre,sepulchre +sepulchure,sepulchre,sepulchre +sepulcre,sepulchre,sepulchre +seqence,sequence +seqenced,sequenced +seqences,sequences +seqencing,sequencing +seqense,sequence +seqensed,sequenced +seqenses,sequences +seqensing,sequencing +seqenstial,sequential +seqential,sequential +seqeuencer,sequencer +seqeuental,sequential +seqeunce,sequence +seqeuncer,sequencer +seqeuntials,sequentials +sequcne,sequence +sequece,sequence +sequeces,sequences +sequeence,sequence +sequelce,sequence +sequemce,sequence +sequemces,sequences +sequencial,sequential +sequencially,sequentially +sequencies,sequences +sequense,sequence +sequensed,sequenced +sequenses,sequences +sequensing,sequencing +sequenstial,sequential +sequentialy,sequentially +sequenzes,sequences +sequetial,sequential +sequeze,squeeze,sequence +sequnces,sequences +ser,set +serach,search serached,searched seraches,searches seraching,searching +serailisation,serialisation +serailization,serialization +serailized,serialized +serailze,serialize +serailzed,serialized serbain,serbian +sercive,service +sercived,serviced +sercives,services +serciving,servicing serenitary,serenity serentiy,serenity sergaent,sergeant sergeat,sergeant sergent,sergeant +serialiazation,serialization seriban,serbian +serice,service +serices,services,series +serie,series +serieses,series +serios,serious seriosuly,seriously serioulsy,seriously +seriouly,seriously +seriuos,serious seriuosly,seriously +serivce,service serivceable,serviceable +serivces,services +sersies,series +sertificate,certificate +sertificated,certificated sertificates,certificates +sertification,certification servans,servants servantes,servants +servce,service,serve +servced,serviced,served +servces,services,serves +servcing,servicing,serving +servece,service +serveced,serviced +serveces,services +servecing,servicing +serveice,service +serveiced,serviced +serveices,services +serveicing,servicing serveillance,surveillance +serveral,several +serverite,severity +serverites,severities +serveritie,severity,severities +serverities,severities +serverity,severity serviceble,serviceable serviciable,serviceable +servie,service +servies,services +servive,service +servoce,service +servoced,serviced +servoces,services +servocing,servicing +serwer,server,sewer +sesitive,sensitive seskatchewan,saskatchewan sesnors,sensors +sessio,session +sesssion,session +sesssions,sessions +sestatusbar,setstatusbar +sestatusmsg,setstatusmsg +setgit,setgid +seting,setting +setings,settings +setion,section +setions,sections +setis,settees +setitng,setting +setitngs,settings +setquential,sequential +setted,set settelement,settlement settelment,settlement settelments,settlements settigns,settings +settigs,settings +settinga,settings +settingss,settings settins,settings settlemens,settlements settlemetns,settlements settlemets,settlements settlemnts,settlements settlment,settlement +settng,setting +settter,setter +settters,setters +settting,setting +setttings,settings +settup,setup +seuence,sequence +seuences,sequences seuxalized,sexualized +sevaral,several +seve,save,sieve seventeeen,seventeen seventen,seventeen severeal,several severeid,severed severide,severed +severirirty,severity +severirities,severities +severite,severity +severites,severities +severitie,severity,severities +severl,several severley,severely severly,severely sevice,service +sevrity,severity +sewdonim,pseudonym +sewdonims,pseudonyms +sewrvice,service sexaulized,sexualized sexaully,sexually sexualixed,sexualized @@ -23208,8 +43229,11 @@ sexulaized,sexualized seziure,seizure seziures,seizures sezuires,seizures +sfety,safety +sgadow,shadow shadasloo,shadaloo shaddow,shadow +shadhow,shadow shadoloo,shadaloo shakeapeare,shakespeare shakepseare,shakespeare @@ -23222,8 +43246,12 @@ shamelesly,shamelessly shamelessely,shamelessly shamelessley,shamelessly shamelessy,shamelessly -shamen,shaman +shamen,shaman,shamans shampionship,championship +shandeleer,chandelier +shandeleers,chandeliers +shandow,shadow +shaneal,chenille shanenigans,shenanigans shangahi,shanghai shanghi,shanghai @@ -23233,36 +43261,56 @@ shaprie,sharpie shaprly,sharply shaprness,sharpness shardholders,shareholders +shareed,shared shareholdes,shareholders shareholds,shareholders sharipe,sharpie sharkening,sharpening +sharloton,charlatan sharpeneing,sharpening sharpenning,sharpening sharpenss,sharpness sharpining,sharpening sharplay,sharply sharpley,sharply +sharraid,charade +sharraids,charades shartening,sharpening +shashes,slashes shatnering,shattering +shatow,château shattening,shattering shatterling,shattering shatterring,shattering shawhsank,shawshank shawshak,shawshank +shbang,shebang shcemes,schemes shcizophrenic,schizophrenic shcolars,scholars shcooled,schooled sheakspeare,shakespeare +sheat,sheath,sheet,cheat +sheck,check,check,shuck +shecked,checked,shucked +shecker,checker,shucker +shecking,checking,shucking +shecks,checks,checks,shucks +shedule,schedule +sheduled,scheduled +shedules,schedules +sheduling,scheduling sheelpe,sheeple sheepel,sheeple +sheepherd,shepherd +sheepherds,shepherds sheild,shield sheilded,shielded sheilding,shielding shelterd,sheltered shelvers,shelves shelveys,shelves +sheme,scheme,shame shenadigans,shenanigans shenanagans,shenanigans shenanagins,shenanigans @@ -23278,9 +43326,13 @@ shenanigins,shenanigans shenenigans,shenanigans sheninigans,shenanigans shennaigans,shenanigans +shepe,shape shepharded,shepherd shephed,shepherd shephered,shepherd +shepre,sphere +shepres,spheres +sherif,sheriff sherlcok,sherlock sherlok,sherlock shetler,shelter @@ -23288,7 +43340,9 @@ shetlers,shelters shevles,shelves shfiter,shifter shfiting,shifting +shicane,chicane shieldd,shielded +shif,shift shifitng,shifting shifteer,shifter shileded,shielded @@ -23309,39 +43363,103 @@ shleter,shelter shletered,sheltered shleters,shelters shnaghai,shanghai +shoftware,software +shoild,should +shoing,showing +shold,should,hold,sold +sholder,shoulder +sholuld,should shopkeeepers,shopkeepers +shorcuts,shortcuts shorly,shortly +shortcat,shortcut +shortcats,shortcuts +shortcomming,shortcoming +shortcommings,shortcomings shortend,shortened shortenend,shortened shortenning,shortening shortenting,shortening +shortern,shorten shortining,shortening +shortkut,shortcut +shortkuts,shortcuts +shotcut,shortcut +shotdown,shutdown shotuout,shoutout +shoucl,should +shoud,should shoudl,should +shoudld,should +shoudle,should shoudlers,shoulders shoudln,should shoudlnt,shouldnt +shoudn,shouldn +shoudt,should +shouldbe,should shouldes,shoulders shouldnot,shouldnt shouldt,shouldnt +shoule,should shoulndt,shouldnt +shouls,should +shoult,should +shouod,should shoutot,shoutout +shouw,show +shouws,shows showboarding,snowboarding showede,showered showerd,showered +showfer,chauffeur,shower +showvinism,chauvinism +shpae,shape +shpaes,shapes +shpapes,shapes +shpere,sphere shperes,spheres shperical,spherical +shpped,shipped shrapenl,shrapnel shreak,shriek shrelock,sherlock +shreshold,threshold +shriks,shrinks shriley,shirley shrinked,shrunk shrpanel,shrapnel shtiless,shitless +shtop,stop,shop +shtoped,stopped,shopped +shtopes,stops,shops +shtoping,stopping,shopping +shtopp,stop,shop +shtopped,stopped,shopped +shtoppes,stops,shops +shtopping,stopping,shopping +shtops,stops,shops +shttp,https +shuld,should shuoldnt,shouldnt +shure,sure +shurely,surely +shutdownm,shutdown +shuting,shutting +shutodwn,shutdown shwashank,shawshank +shwo,show +shystem,system +shystemerror,systemerror +shystemmemory,systemmemory +shystems,systems +shystemwindow,systemwindow +sibiling,sibling siblins,siblings +sicinct,succinct +sicinctly,succinctly sicne,since +sidde,side sidebaord,sideboard sideboad,sideboard sidelen,sideline @@ -23350,23 +43468,54 @@ sidelinjen,sideline sidelinked,sideline sideral,sidereal sidleine,sideline +siduction,seduction +sie,size,sigh +sies,size,sighs +siez,size,seize siezable,sizable -sieze,seize -siezed,seized -siezing,seizing +sieze,seize,size +siezed,seized,sized +siezing,seizing,sizing siezure,seizure siezures,seizures +siffix,suffix +siffixation,suffixation,suffocation +siffixed,suffixed +siffixes,suffixes +siffixing,suffixing +sigal,signal,sigil +sigaled,signaled +sigals,signals,sigils siganture,signature sigantures,signatures +sigen,sign sightstine,sightstone +sigificance,significance siginificant,significant +siginificantly,significantly +siginify,signify +sigit,digit +sigits,digits +sigle,single,sigil +sigles,singles,sigils +sigleton,singleton +signabl,signable,signal +signales,signals +signall,signal signapore,singapore -signatue,signatures +signatue,signatures,signature +signatur,signature signficant,significant +signficantly,significantly signficiant,significant signfies,signifies signfiy,signify +signguature,signature +signifanct,significant +signifant,significant signifantly,significantly +signifcant,significant +signifcantly,significantly signifiant,significant significane,significance significanlty,significantly @@ -23386,18 +43535,23 @@ signins,signings signitories,signatories signitory,signatory signitures,signatures +signle,single,signal signleplayer,singleplayer -signles,singles +signles,singles,signals +signol,signal +signul,signal signular,singular signularity,singularity sigthstone,sightstone sihlouette,silhouette silbings,siblings silders,sliders +silentely,silently silenty,silently silhouete,silhouette silicoln,silicon silicoon,silicon +siliently,silently,saliently silimiar,similar silohuette,silhouette silouhette,silhouette @@ -23405,7 +43559,11 @@ simaltaneous,simultaneous simaltaneously,simultaneously simeltaneous,simultaneous simeltaneously,simultaneously +simeple,simple +simgle,single simialir,similar +simialr,similar +simiar,similar simiilar,similar similair,similar similairty,similarity @@ -23417,6 +43575,8 @@ similarlity,similarity similarlly,similarly similart,similarity similary,similarly +similat,similar +similia,similar similiair,similar similiar,similar similiarites,similarities @@ -23424,14 +43584,22 @@ similiarity,similarity similiarly,similarly similiarties,similarities similiarty,similarity +similiary,similarity similir,similar similiraties,similarities similtaneous,simultaneous similtaneously,simultaneously +simily,simile,smiley,simply,similarly +simlar,similar +simlarlity,similarity +simlarly,similarly +simle,simple,smile,simile simliar,similar simliarities,similarities simliarity,similarity simliarly,similarly +simlicity,simplicity +simlified,simplified simliiar,similar simluate,simulate simluated,simulated @@ -23440,18 +43608,27 @@ simluations,simulations simluator,simulator simlutaneous,simultaneous simlutaneously,simultaneously +simly,simply,simile,smiley +simmetric,symmetric +simmetrical,symmetrical +simmetry,symmetry simmilar,similar simpathizers,sympathizers simpelst,simplest +simpified,simplified simplefying,simplifying +simplei,simply simplet,simplest simplets,simplest simpley,simply simplfy,simplify simplicitly,simplicity simplictic,simplistic +simplicty,simplicity simplicy,simplicity simplier,simpler +simplies,implies,simplifies +simpliest,simplest simplificacion,simplification simplificaiton,simplification simplificating,simplification @@ -23460,6 +43637,9 @@ simplifing,simplifying simplifiy,simplify simplifyed,simplified simplifyng,simplifying +simplifys,simplifies +simpliifcation,simplification +simpliifcations,simplifications simplisitc,simplistic simplisitic,simplistic simplisity,simplicity @@ -23470,6 +43650,7 @@ simpliy,simplify simplyfied,simplified simplyifing,simplifying simposn,simpson +simpy,simply simspon,simpson simualted,simulated simualtion,simulation @@ -23477,6 +43658,18 @@ simualtions,simulations simualtor,simulator simulacion,simulation simulaiton,simulations +simulantaneous,simultaneous +simulantaneously,simultaneously +simulataeous,simultaneous +simulataeously,simultaneously +simulataneity,simultaneity +simulataneous,simultaneous +simulataneously,simultaneously +simulatanious,simultaneous +simulataniously,simultaneously +simulatanous,simultaneous +simulatanously,simultaneously +simulatation,simulation simulatenous,simultaneous simulatenously,simultaneously simulatie,simulate @@ -23504,24 +43697,58 @@ simultanous,simultaneous simultanously,simultaneously simulteanously,simultaneously simulteneous,simultaneous +simutaneously,simultaneously sinagpore,singapore +sinature,signature sincereley,sincerely sincerelly,sincerely sincerley,sincerely +sincerly,sincerely +singal,signal,single +singaled,signaled singals,signals singature,signature singatures,signatures +singel,single,signal +singelar,singular +singelarity,singularity +singelarly,singularly +singeled,singled,signaled +singeles,singles,signals singelplayer,singleplayer singels,singles +singelton,singleton +singificand,significand,significant singificantly,significantly singify,signify +singlar,singular singlepalyer,singleplayer singlers,singles +singls,singles,single +singlton,singleton +singltons,singletons singluar,singular singluarity,singularity +singlular,singular +singlularly,singularly +singnal,signal +singnalled,signalled +singnals,signals +singol,signal,single +singolar,singular +singoled,signaled,singled +singols,signals,singles +singool,single,signal +singoolar,singular +singoolarity,singularity +singoolarly,singularly +singooled,singled,signaled +singools,singles,signals singpaore,singapore singsog,singsong singualrity,singularity +singuarity,singularity +singuarl,singular singulair,singular singulaire,singular singulairty,singularity @@ -23529,25 +43756,111 @@ singularily,singularity singulariy,singularity singularty,singularity singulary,singularity +singulaties,singularities singulator,singular sinistre,sinister +sinlge,single sinlgeplayer,singleplayer -sinse,sines +sinlges,singles +sinply,simply +sinse,sines,since sinsiter,sinister +sintac,syntax +sintacks,syntax +sintacs,syntax +sintact,syntax +sintacts,syntax +sintak,syntax +sintaks,syntax +sintakt,syntax +sintakts,syntax +sintax,syntax +sionist,zionist +sionists,zionists +siply,simply +sircle,circle +sircles,circles +sircular,circular +sirect,direct +sirected,directed +sirecting,directing +sirection,direction +sirectional,directional +sirectionalities,directionalities +sirectionality,directionality +sirectionals,directionals +sirectionless,directionless +sirections,directions +sirective,directive +sirectives,directives +sirectly,directly +sirectness,directness +sirector,director +sirectories,directories +sirectors,directors +sirectory,directory +sirects,directs +sise,size,sisal +sisnce,since +sistem,system sistematically,systematically +sistematics,systematics +sistematies,systematies +sistematising,systematising +sistematizing,systematizing +sistematy,systematy +sistemed,systemed +sistemic,systemic +sistemically,systemically +sistemics,systemics +sisteming,systemic,stemming +sistemist,systemist +sistemists,systemists +sistemize,systemize +sistemized,systemized +sistemizes,systemizes +sistemizing,systemizing +sistems,systems +sitation,situation +sitations,situations +sitaution,situation sitautional,situational sitautions,situations +sitck,stick sitckers,stickers +siteu,site +sitll,still sitmuli,stimuli sitrring,stirring situacional,situational situatinal,situational -situationals,situations -situationly,situational +situationals,situations,situational +situationly,situational,situationally situationnal,situational +situatuion,situation +situatuions,situations +situatution,situation +situatutions,situations +situbbornness,stubbornness +situdio,studio +situdios,studios +situration,situation +siturations,situations +situtaion,situation +situtaions,situations +situtation,situation +situtations,situations siutational,situational -sixtin,sistine +siute,suite +sivible,visible +siwtch,switch +siwtched,switched +siwtching,switching +sixtin,sistine,sixteen sizebale,sizeable +sizre,size +skagerak,skagerrak +skalar,scalar skandinavian,scandinavian skatebaord,skateboard skatebaording,skateboarding @@ -23560,14 +43873,18 @@ skateborading,skateboarding skatebored,skateboard skatebrand,skateboard skateing,skating +skecth,sketch skecthes,sketches skecthy,sketchy +skeep,skip skelatel,skeletal skeletaal,skeletal skeletl,skeletal skeletones,skeletons skeletos,skeletons +skelton,skeleton skepitcal,skeptical +skept,skipped skeptecism,skepticism skepticals,skeptics skepticim,skepticism @@ -23584,6 +43901,9 @@ sketpic,skeptic sketpical,skeptical sketpicism,skepticism sketpics,skeptics +skilfull,skilful,skilful +skillfull,skillful,skillful,skillfully,skillfully +skillfullness,skillfulness,skillfulness skillhosts,skillshots skillshits,skillshots skillshoot,skillshots @@ -23594,6 +43914,12 @@ skillsofts,skillshots skillsshot,skillshots skillsto,skillshots skimrish,skirmish +skipd,skipped +skiped,skipped,skyped +skiping,skipping +skipp,skip,skipped +skippd,skipped +skipt,skip,skype,skipped skirmiches,skirmish skpetic,skeptic skpeticism,skepticism @@ -23603,8 +43929,12 @@ skrimish,skirmish skteches,sketches sktechy,sketchy skwyard,skyward +skyp,skip,skype skywalkr,skywalker slaptoon,splatoon +slase,slash +slases,slashes +slashs,slashes slaughted,slaughtered slaughterd,slaughtered slaugterhouses,slaughterhouses @@ -23615,25 +43945,47 @@ slavage,salvage slaverly,slavery slayign,slaying sldiers,sliders +slect,select +slected,selected +slecting,selecting +slection,selection +sleect,select +sleeped,slept +sleepp,sleep slefies,selfies slefishness,selfishness +slicable,sliceable slienced,silenced +slient,silent sliently,silently slighlty,slightly slighly,slightly +slightl,slightly slighty,slightly +slignt,slight +sligntly,slightly +sligth,slight sligthly,slightly +sligtly,slightly +sliped,slipped slipperies,slippers slipperly,slippery slippes,slippers slippey,slippery +sliseshow,slideshow sloughtering,slaughtering slowy,slowly sluaghter,slaughter sluaghtered,slaughtered sluaghtering,slaughtering +sluggify,slugify smackdwon,smackdown smae,same +smal,small +smaler,smaller +smallar,smaller +smalles,smallest +smaple,sample smaples,samples smarpthone,smartphones smartare,smarter @@ -23643,14 +43995,34 @@ smartre,smarter smaurai,samurai smealting,smelting smeesters,semesters +smething,something +smll,small,smell +smller,smaller smoe,some +smoot,smooth +smooter,smoother +smoothign,smoothing +smooting,smoothing +smouth,smooth +smouthness,smoothness +smove,move +smpt,smtp,smtpe snadler,sandler snadstorm,sandstorm snadwiches,sandwiches +snaped,snapped +snaphot,snapshot +snaphsot,snapshot +snaping,snapping +snappng,snapping +snapsnot,snapshot +snapsnots,snapshots sneeks,sneaks snese,sneeze snetries,sentries snigles,singles +snipet,snippet +snipets,snippets snippent,snippet snippert,snippet snippes,snippets @@ -23668,17 +44040,23 @@ snowfalke,snowflake snowfalling,snowballing snowflaek,snowflake snowlfake,snowflake +snpashot,snapshot +snpashots,snapshots snugglie,snuggle snwoballs,snowballs snwoden,snowden +snyc,sync snycing,syncing snydrome,syndrome snyergy,synergy snyopsis,synopsis +snytax,syntax snythesis,synthesis snythetic,synthetic +soalris,solaris soberity,sobriety sobreity,sobriety +socail,social socailism,socialism socailist,socialist socailists,socialists @@ -23689,6 +44067,7 @@ socailly,socially socalism,socialism socartes,socrates soceities,societies +socekts,sockets socialicing,socializing socialim,socialism socialini,socializing @@ -23733,41 +44112,73 @@ socratees,socrates socrateks,socrates socreboard,scoreboard socttish,scottish +soecialize,specialized soem,some soemthin,somethin soemthing,something soemthings,somethings +soemwhere,somewhere +sofisticated,sophisticated +softend,softened +softwares,software +softwre,software sofware,software +sofwtare,software sohpisticated,sophisticated sohpomore,sophomore sohw,show soilders,soldiers soildly,solidly +soiurce,source +soket,socket +sokets,sockets +solarmutx,solarmutex solatary,solitary soldeirs,soldiers soldiarity,solidarity soldies,soldiers soldily,solidly +soler,solver,solar,solely soley,solely +solf,solve,sold +solfed,solved +solfer,solver,solder +solfes,solves +solfing,solving +solfs,solves solidairty,solidarity solidariety,solidarity soliders,soldiers soliditary,solidarity +solification,solidification soliliquy,soliloquy solitudine,solitude +soltion,solution soluable,soluble +solum,solemn solutide,solitude +solveable,solvable +solwed,solved +som,some somaila,somalia somalija,somalia +someboby,somebody somehtin,something somehting,something somehtings,somethings +somehwat,somewhat +somehwere,somewhere +somehwo,somehow somene,someone +somenone,someone someoens,someones +someon,someone someoneis,someones someonelse,someones someons,someones +somes,some somethibng,something +somethig,something somethign,something somethigng,something somethigns,somethings @@ -23775,6 +44186,8 @@ somethihng,something somethiing,something somethijng,something somethikng,somethin +somethimes,sometimes +somethimg,something somethimng,something somethinbg,somethings somethines,somethings @@ -23793,13 +44206,43 @@ somethiong,something somethis,somethings somethiung,something somethn,something +sometiem,sometime,sometimes +sometiems,sometimes +sometihing,something sometihn,something +sometihng,something +sometiles,sometimes +sometims,sometimes +sometines,sometimes +someting,something sometinh,something +sometinhg,something +somewere,somewhere +somewher,somewhere +somewho,somehow +somme,some somoenes,someones +somthign,something +somthing,something somtimes,sometimes +somwhat,somewhat somwhere,somewhere +somwho,somehow +somwhow,somehow +sonething,something +songlar,singular +songle,single,dongle +songled,singled,dongled +songles,singles,dongles +songling,singling,dongling +sooaside,suicide +soodonim,pseudonym +sooit,suet,suit,soot +soop,soup,scoop,snoop,soap +soource,source soparnos,sopranos sophicated,sophisticated +sophisicated,sophisticated sophisitcated,sophisticated sophistacated,sophisticated sophisticaed,sophisticated @@ -23808,21 +44251,41 @@ sophistocated,sophisticated sophmore,sophomore sophosticated,sophisticated sopohmore,sophomore +sorce,source,force sorcercy,sorcery sorcerey,sorcery sorceror,sorcerer sorcerry,sorcery sorpanos,sopranos sorrounding,surrounding +sortig,sorting +sortings,sorting +sortlst,sortlist +sortner,sorter +sortnr,sorter +sortrage,storage,shortage +soruce,source,spruce +soruces,sources,spruces +soscket,socket +soterd,stored,sorted +sotfware,software +sotrage,storage,shortage +sotred,sorted,stored +sotring,storing,sorting sotrmfront,stormfront -sotry,story +sotry,story,sorry sotryline,storyline sotrylines,storylines -sotyr,satyr +sotyr,satyr,story +souce,source +souces,sources +soucre,source +soucres,sources soudn,sound soudns,sounds soudntrack,soundtrack -sould,could +sould,could,should,sold +soundard,soundcard soundrtack,soundtracks soundtracs,soundtracks soundtrak,soundtrack @@ -23831,6 +44294,16 @@ soundtrakcs,soundtracks soundtrakk,soundtrack soundtraks,soundtracks sountrack,soundtrack +sourcd,sourced,source +sourcde,sourced,source +sourcedrectory,sourcedirectory +sourcs,sources,source +sourcse,sources,source +sourct,source +soure,source,sure,sore,sour,soured +soures,sources,sores,sours,soured +sourrounding,surrounding +sourt,sort,south,sour sourth,south sourthern,southern southampon,southampton @@ -23839,6 +44312,7 @@ southamton,southampton southamtpon,southampton southanpton,southampton southapmton,southampton +southbrige,southbridge southen,southern southerers,southerners southernerns,southerners @@ -23854,6 +44328,7 @@ southtampon,southampton souvenier,souvenir souveniers,souvenirs soveits,soviets +sover,solver soveregin,sovereign soveregnity,sovereignty sovereighnty,sovereignty @@ -23873,11 +44348,22 @@ soverign,sovereign soverignity,sovereignty soverignty,sovereignty sovietes,soviets +sovle,solve +sovled,solved +sovren,sovereign +sowe,sow spacebr,spacebar spacegoat,scapegoat +spacific,specific spacification,specification +spacifics,specifics +spacified,specified +spacifies,specifies spagehtti,spaghetti +spageti,spaghetti +spagetti,spaghetti spagheti,spaghetti +spagnum,sphagnum spahgetti,spaghetti spainish,spanish spainsh,spanish @@ -23887,9 +44373,12 @@ spammare,spammer spammear,spammer spammend,spammed spammeur,spammer +spaning,spanning spanisch,spanish spansih,spanish spanwed,spawned +sparate,separate +sparately,separately sparkel,sparkle sparklie,sparkle sparlking,sparkling @@ -23899,10 +44388,24 @@ spartants,spartans spartas,spartans spartsn,spartans sparyed,sprayed +spaw,spawn +spawed,spawned spawend,spawned +spawing,spawning +spawining,spawning spawnig,spawning spawnign,spawning +spawnve,spawn +spaws,spawns +spcae,space +spcecified,specified +spcial,special +spcific,specific +spcifies,specifies speach,speech +speacial,special,spacial +spearator,separator +spearators,separators specail,special specailist,specialist specailists,specialists @@ -23914,13 +44417,24 @@ specailly,specially specailty,specialty specality,speciality specatcular,spectacular +specefied,specified specemin,specimen specfic,specific +specfically,specifically +specfication,specification +specfications,specifications +specfied,specified +specfield,specified +specfies,specifies +specfiied,specified +specfy,specify +specfying,specifying speciaal,special +speciafied,specified speciales,specials specialication,specialization specialice,specialize -specialiced,specialized +specialiced,specialized,specialised specialices,specializes specialied,specialized specialies,specializes @@ -23928,6 +44442,7 @@ specialis,specials specialistes,specialists specialites,specializes specialits,specials +specialitzed,specialized,specialized specializaiton,specialization specializare,specialize specializate,specialize @@ -23937,7 +44452,7 @@ specializied,specialize speciallist,specialist speciallity,specially speciallize,specialize -speciallized,specialized +speciallized,specialized,specialized speciallly,specially speciallty,specially specialops,specials @@ -23951,30 +44466,80 @@ specialzes,specializes specialzied,specialized specias,specials speciatly,specialty +specic,specific +specical,special +specication,specification +specidic,specific +specied,specified +speciefied,specified +specifactions,specifications +specifc,specific specifcally,specifically specifcation,specification +specifcations,specifications +specifcied,specified +specifclly,specifically specifed,specified +speciffic,specific +speciffically,specifically +specifially,specifically specificaiton,specifications specificaitons,specification +specificallly,specifically specificaly,specifically +specificated,specified +specificateion,specification +specificatin,specification specificato,specification +specificaton,specification specificatons,specifications -specifices,specifics +specificed,specified +specifices,specifics,specifies +specifich,specify,specific +specificially,specifically +specificiation,specification +specificiations,specifications +specificically,specifically +specificied,specified specificies,specifics +specificl,specific +specificly,specifically +specifiction,specification +specifictions,specifications +specificy,specify,specificity,specifically +specifid,specified specifiing,specifying specifikation,specification specifing,specifying specifiy,specify specifiying,specifying specifiyng,specifying +specifric,specific +specift,specify +specifyed,specified +specifyied,specified +specifyig,specifying +specifyinhg,specifying +speciied,specified +speciifc,specific +speciifed,specified specilaized,specialize speciliast,specialists speciliazation,specialization speciliazed,specialize +specilized,specialized speciman,specimen specimine,specimen specimines,specimen +speciries,specifies +speciry,specify specisl,specials +specivied,specified +speciy,specify +speciyfing,specifying +speciyfying,specifying +speciying,specifying +specktor,specter,specter specrtal,spectral spectacuarly,spectacular spectaculair,spectacular @@ -23996,20 +44561,293 @@ spectracal,spectral spectrail,spectral spectraply,spectral spectrolab,spectral -spects,aspects +spects,aspects,expects,specs +spectular,spectacular +spectularly,spectacularly spectum,spectrum +specturm,spectrum specualte,speculate specualting,speculating specualtion,speculation specualtions,speculation specualtive,speculative +specufies,specifies +specufy,specify specularite,speculative speculatie,speculative speculaties,speculative speculatin,speculation +spedific,specific +spedified,specified +spedify,specify +speeak,speak +speeaking,speaking speecheasy,speeches speechers,speeches speechs,speeches +speeling,spelling +speelling,spelling +speep,sleep +speeped,sped +speeping,sleeping +spefally,specially,specifically +spefation,separation,specification +spefations,separations,specifications +spefcifiable,specifiable +spefcific,specific +spefcifically,specifically +spefcification,specification +spefcifications,specifications +spefcifics,specifics +spefcifieid,specified +spefcifieir,specifier +spefcifieirs,specifiers +spefcifieis,specifies +spefcifiy,specify +spefcifiying,specifying +spefeid,specified +spefeir,specifier +spefeirs,specifiers +spefeis,specifies +spefiable,specifiable +spefial,special +spefic,specific +speficable,specifiable +spefically,specifically +spefication,specification +spefications,specifications +speficed,specified +speficeid,specified +speficeir,specifier +speficeirs,specifiers +speficeis,specifies +speficer,specifier +speficers,specifiers +spefices,specifies +speficiable,specifiable +speficiallally,specifically +speficiallation,specification +speficiallations,specifications +speficialleid,specified +speficialleir,specifier +speficialleirs,specifiers +speficialleis,specifies +speficialliable,specifiable +speficiallic,specific +speficiallically,specifically +speficiallication,specification +speficiallications,specifications +speficiallics,specifics +speficiallied,specified +speficiallier,specifier +speficialliers,specifiers +speficiallies,specifies +speficiallifed,specified +speficiallifer,specifier +speficiallifers,specifiers +speficiallifes,specifies +speficially,specifically +speficiation,specification +speficiations,specifications +speficic,specific +speficically,specifically +speficication,specification +speficications,specifications +speficics,specifics +speficied,specified +speficieid,specified +speficieir,specifier +speficieirs,specifiers +speficieis,specifies +speficier,specifier +speficiers,specifiers +speficies,specifies +speficifally,specifically +speficifation,specification +speficifations,specifications +speficifc,specific +speficifcally,specifically +speficifcation,specification +speficifcations,specifications +speficifcs,specifics +speficifed,specified +speficifeid,specified +speficifeir,specifier +speficifeirs,specifiers +speficifeis,specifies +speficifer,specifier +speficifers,specifiers +speficifes,specifies +speficifiable,specifiable +speficific,specific +speficifically,specifically +speficification,specification +speficifications,specifications +speficifics,specifics +speficified,specified +speficifier,specifier +speficifiers,specifiers +speficifies,specifies +speficififed,specified +speficififer,specifier +speficififers,specifiers +speficififes,specifies +speficify,specify +speficifying,specifying +speficiiable,specifiable +speficiic,specific +speficiically,specifically +speficiication,specification +speficiications,specifications +speficiics,specifics +speficiied,specified +speficiier,specifier +speficiiers,specifiers +speficiies,specifies +speficiifed,specified +speficiifer,specifier +speficiifers,specifiers +speficiifes,specifies +speficillally,specifically +speficillation,specification +speficillations,specifications +speficilleid,specified +speficilleir,specifier +speficilleirs,specifiers +speficilleis,specifies +speficilliable,specifiable +speficillic,specific +speficillically,specifically +speficillication,specification +speficillications,specifications +speficillics,specifics +speficillied,specified +speficillier,specifier +speficilliers,specifiers +speficillies,specifies +speficillifed,specified +speficillifer,specifier +speficillifers,specifiers +speficillifes,specifies +speficilly,specifically +speficitally,specifically +speficitation,specification +speficitations,specifications +speficiteid,specified +speficiteir,specifier +speficiteirs,specifiers +speficiteis,specifies +speficitiable,specifiable +speficitic,specific +speficitically,specifically +speficitication,specification +speficitications,specifications +speficitics,specifics +speficitied,specified +speficitier,specifier +speficitiers,specifiers +speficities,specificities +speficitifed,specified +speficitifer,specifier +speficitifers,specifiers +speficitifes,specifies +speficity,specificity +speficiy,specify +speficiying,specifying +spefics,specifics +speficy,specify +speficying,specifying +spefied,specified +spefier,specifier +spefiers,specifiers +spefies,specifies +spefifally,specifically +spefifation,specification +spefifations,specifications +spefifed,specified +spefifeid,specified +spefifeir,specifier +spefifeirs,specifiers +spefifeis,specifies +spefifer,specifier +spefifers,specifiers +spefifes,specifies +spefifiable,specifiable +spefific,specific +spefifically,specifically +spefification,specification +spefifications,specifications +spefifics,specifics +spefified,specified +spefifier,specifier +spefifiers,specifiers +spefifies,specifies +spefififed,specified +spefififer,specifier +spefififers,specifiers +spefififes,specifies +spefify,specify +spefifying,specifying +spefiiable,specifiable +spefiic,specific +spefiically,specifically +spefiication,specification +spefiications,specifications +spefiics,specifics +spefiied,specified +spefiier,specifier +spefiiers,specifiers +spefiies,specifies +spefiifally,specifically +spefiifation,specification +spefiifations,specifications +spefiifeid,specified +spefiifeir,specifier +spefiifeirs,specifiers +spefiifeis,specifies +spefiifiable,specifiable +spefiific,specific +spefiifically,specifically +spefiification,specification +spefiifications,specifications +spefiifics,specifics +spefiified,specified +spefiifier,specifier +spefiifiers,specifiers +spefiifies,specifies +spefiififed,specified +spefiififer,specifier +spefiififers,specifiers +spefiififes,specifies +spefiify,specify +spefiifying,specifying +spefixally,specifically +spefixation,specification +spefixations,specifications +spefixeid,specified +spefixeir,specifier +spefixeirs,specifiers +spefixeis,specifies +spefixiable,specifiable +spefixic,specific +spefixically,specifically +spefixication,specification +spefixications,specifications +spefixics,specifics +spefixied,specified +spefixier,specifier +spefixiers,specifiers +spefixies,specifies +spefixifed,specified +spefixifer,specifier +spefixifers,specifiers +spefixifes,specifies +spefixy,specify +spefixying,specifying +spefiy,specify +spefiying,specifying +spefy,specify +spefying,specifying spehres,spheres spehrical,spherical speical,special @@ -24017,21 +44855,50 @@ speicalist,specialist speically,specially speicals,specials speices,species +speicfied,specified +speicific,specific +speicified,specified +speicify,specify +speling,spelling spellig,spelling spellign,spelling +spellshecking,spellchecking spendour,splendour +speparate,separate +speparated,separated +speparating,separating +speparation,separation +speparator,separator +spepc,spec +sperate,separate +sperately,separately spermatozoan,spermatozoon +speshal,special +speshally,specially,especially +speshel,special +speshelly,specially,especially +spesialisation,specialisation spesifically,specifically spesification,specification spesifications,specifications +spesified,specified +spesify,specify spetember,september -spezialisation,specialisation +spezialisation,specialisation,specialisation +spezific,specific +spezified,specified +spezify,specify sphagetti,spaghetti sphereos,spheres +spicific,specific +spile,spite,spiral spilnter,splinter spiltter,splitter +spiltting,splitting spindel,spindle spindrel,spindle +spinlcok,spinlock +spinock,spinlock spiritd,spirited spirites,spirits spiritis,spirits @@ -24051,8 +44918,16 @@ spitirually,spiritually splaton,splatoon splatooon,splatoon spleling,spelling +splig,split,splign +spligs,splits +spliitting,splitting +splite,split,splits,splice +spliting,splitting splitner,splinter +splitted,split +splittng,splitting splittr,splitter +spllitting,splitting spoace,space spoilerd,spoiled spoiles,spoilers @@ -24065,6 +44940,7 @@ sponatneous,spontaneous sponosred,sponsored sponser,sponsor sponsered,sponsored +sponsers,sponsors sponsership,sponsorship sponsord,sponsored sponsorees,sponsors @@ -24097,6 +44973,8 @@ sponteneously,spontaneously sponzored,sponsored spoonfulls,spoonfuls sporanos,sopranos +sporatic,sporadic +sporious,spurious sporles,sproles sporstmanship,sportsmanship sportmansship,sportsmanship @@ -24108,6 +44986,11 @@ spotfiy,spotify spotifiy,spotify spotifty,spotify sppeches,speeches +spped,speed,sped,sipped,sapped,supped,sopped +spport,support +spported,supported +spporting,supporting +spports,supports sprakling,sparkling sprayade,sprayed spreaded,spread @@ -24121,8 +45004,16 @@ spreadsheeters,spreadsheets spreadsheeticus,spreadsheets spreadshet,spreadsheet spreadshets,spreadsheets +spreasheet,spreadsheet +spreasheets,spreadsheets +sprech,speech +sprecial,special +sprecialized,specialized +sprecially,specially spred,spread +spredsheet,spreadsheet spreedsheet,spreadsheet +sprinf,sprintf springfeild,springfield springfeld,springfield springfied,springfield @@ -24136,15 +45027,29 @@ sprintas,sprints spriritual,spiritual spritual,spiritual sproels,sproles +sproon,spoon sprotsmanship,sportsmanship sproutes,sprouts +spsace,space +spsaces,spaces +sptintf,sprintf +spurios,spurious +spurrious,spurious spwaned,spawned spwaning,spawning +sqare,square +sqared,squared +sqares,squares +sqash,squash +sqashed,squashed +sqashing,squashing sqaudron,squadron sqaure,square +sqaured,squared sqaurely,squarely sqaures,squares sqeuaky,squeaky +sqeuence,sequence sqiurtle,squirtle sqiushy,squishy squadroon,squadron @@ -24152,9 +45057,12 @@ squardon,squadron squareds,squares squarey,squarely squarley,squarely +squashgin,squashing squeakey,squeaky squeakly,squeaky -squirel,squirtle +squence,sequence +squirel,squirtle,squirrel +squirl,squirrel squirle,squirrel squirlte,squirtle squirrelies,squirrels @@ -24169,44 +45077,94 @@ squirte,squirtle squirtel,squirtle squishey,squishy squishly,squishy +squrared,squared squritle,squirtle squrriel,squirrel squrriels,squirrels squrtile,squirtle squsihy,squishy +srcipt,script +srcipts,scripts +sreampropinfo,streampropinfo +sreenshot,screenshot +sreenshots,screenshots +sreturns,returns +srew,screw,shrew,sew sriarcha,sriracha +srikeout,strikeout +sring,string +srings,strings +srink,shrink +srinkd,shrunk +srinked,shrunk +srinking,shrinking +sript,script +sripts,scripts sriraca,sriracha srirachia,sriracha srirachra,sriracha +srollbar,scrollbar +srouce,source srpouts,sprouts srriacha,sriracha +srting,string,sorting +srtings,strings +srtructure,structure +sructure,structure +sructures,structures +srunk,shrunk +srunken,shrunken +srunkn,shrunken sryacuse,syracuse sryians,syrians sryinge,syringe +ssee,see +ssome,some +stabalization,stabilization stabelized,stabilized stabilizare,stabilize stabilizied,stabilize stabilizier,stabilize stabilizies,stabilize +stabilty,stability stabilzied,stabilized stabliize,stabilize stablility,stability +stablilization,stabilization +stablize,stabilize stablizied,stabilized +stach,stack +stackk,stack stadius,stadiums +stadnard,standard +stadnardisation,standardisation +stadnardised,standardised +stadnardising,standardising +stadnardization,standardization +stadnardized,standardized +stadnardizing,standardizing +stadnards,standards staduim,stadium staduims,stadiums +stae,state +staement,statement staggaring,staggering staggerring,staggering staggerwing,staggering stagnat,stagnant +staically,statically staidum,stadium staidums,stadiums stainlees,stainless staion,station +staions,stations +staition,station +staitions,stations stakeboard,skateboard stakeboarding,skateboarding stakler,stalker staklers,stalkers +stalagtite,stalactite stalekrs,stalkers stalkear,stalker stalkes,stalkers @@ -24216,14 +45174,35 @@ stampade,stamped stampeed,stamped stancels,stances stancers,stances +standalown,standalone +standar,standard +standarad,standard +standardss,standards +standarized,standardized standars,standards +standart,standard +standartd,standard +standartds,standards +standartisation,standardisation +standartisator,standardiser +standartised,standardised +standartization,standardization +standartizator,standardizer standartized,standardized +standarts,standards +standatd,standard standbay,standby standbuy,standby standerdized,standardized +standtard,standard +standy,standby,sandy,standee stangant,stagnant stange,strange +stanp,stamp staoshi,satoshi +staration,starvation +stard,start +stardard,standard stardardized,standardized staright,straight starighten,straighten @@ -24233,20 +45212,40 @@ starined,strained starins,strains starlted,startled starnation,starvation +startd,started startde,startled startegic,strategic startegically,strategically startegies,strategies startegy,strategy starteld,startled +startet,started +startign,starting +startin,starting +startlisteneing,startlistening startlxde,startled +startnig,starting startsup,startups +startting,starting startupbus,startups startus,startups +starup,startup +starups,startups starwberries,strawberries starwberry,strawberry +statamenet,statement +statamenets,statements stateman,statesman +statemanet,statement statememts,statements +statemen,statement +statemenet,statement +statemenets,statements +statemet,statement +statemnts,statements +stati,statuses +staticly,statically +statictic,statistic statictics,statistics staticts,statist stationair,stationary @@ -24255,10 +45254,15 @@ stationd,stationed stationerad,stationed stationnary,stationary stationy,stationary +statisfied,satisfied +statisfies,satisfies +statisfy,satisfy +statisfying,satisfying statisitc,statistic statisitcal,statistical statisitcally,statistically statisitcs,statistics +statisitics,statistics statiskt,statist statistacally,statistically statistc,statistic @@ -24267,20 +45271,38 @@ statisticaly,statistically statisticly,statistical statistisch,statistics statistisk,statistics +statitic,statistic +statitics,statistics statits,statist +statmenet,statement +statmenmt,statement statment,statement +statments,statements +statrt,start statsit,statist statsitical,statistical +stattistic,statistic stattues,statutes +statubar,statusbar statuer,stature statuets,statutes +statup,startup statuse,statutes statuser,stature +statuss,status +statusses,statuses +statustics,statistics statuts,statutes +staulk,stalk stauration,saturation staurday,saturday staurdays,saturdays +staus,status stautes,statues +stawk,stalk +stcokbrush,stockbrush +stdanard,standard +stdanards,standards steadilly,steadily steadliy,steadily stealhty,stealthy @@ -24294,7 +45316,13 @@ steathly,stealthy steeleries,steelers steeles,steelers stelathy,stealthy +stength,strength steorid,steroid +steram,stream +steramed,streamed +steramer,streamer +steraming,streaming +sterams,streams stereotipe,stereotype stereotipical,stereotypical stereotpye,stereotypes @@ -24309,6 +45337,7 @@ stereotypian,stereotyping stereotypying,stereotyping steriel,sterile sterilze,sterile +sterio,stereo steriods,steroids steriotype,stereotype steriotypes,stereotypes @@ -24330,6 +45359,9 @@ stickes,stickers sticthed,stitched sticthes,stitches sticthing,stitching +stiffneing,stiffening +stiky,sticky +stil,still stilus,stylus stimilants,stimulants stimilated,stimulated @@ -24348,23 +45380,50 @@ stimulaton,stimulation stimulents,stimulants stimulli,stimuli stingent,stringent +stipped,stripped stiring,stirring stirker,striker stirkers,strikers +stirng,string +stirngs,strings +stirr,stir stirrig,stirring stirrs,stirs stitchs,stitches +stivk,stick +stivks,sticks stlaker,stalker stlakers,stalkers +stle,style stlye,style +stlyes,styles stlyish,stylish +stnad,stand +stndard,standard +stocahstic,stochastic +stocastic,stochastic stockpilled,stockpile stockplie,stockpile +stoer,store +stoers,stores stomache,stomach +stompted,stomped stomrfront,stormfront stong,strong +stoped,stopped +stoping,stopping +stopp,stop +stoppped,stopped +stoppping,stopping +stopps,stops stopry,story -storeis,storeys +storag,storage +storeable,storable +storeage,storage +stoream,stream +storeble,storable +storeing,storing +storeis,storeys,storeys,stores storelines,storylines storise,stories stormade,stormed @@ -24376,23 +45435,29 @@ stormfrount,stormfront stornegst,strongest stornfront,stormfront stornghold,stronghold +storys,storeys,storeys storyteling,storytelling storytellling,storytelling stoyr,story stpo,stop +strack,stack,track stradegies,strategies stradegy,strategy +stragedy,strategy,tragedy stragegically,strategically +stragegy,strategy stragetic,strategic stragetically,strategically strageties,strategies stragety,strategy +straighforward,straightforward straightden,straightened straighted,straightened straightend,straightened straightenend,straightened straightforeward,straightforward straightforwad,straightforward +straightfoward,straightforward straightie,straighten straightin,straighten straightmen,straighten @@ -24407,15 +45472,22 @@ straigthen,straighten straigthened,straightened straigthforward,straightforward straind,strained +straines,strains straings,strains straitforward,straightforward +stram,steam,stream,tram +straming,streaming,steaming +strams,steams,streams,trams +stran,strand,strain strangel,strangle strangeshit,strangest stranget,strangest strangets,strangest stranglove,strangle +strangly,strangely,strange,strangle +strangness,strangeness strangreal,strangle -strat,start +strat,start,strata stratagically,strategically stratagies,strategies strategems,strategies @@ -24441,22 +45513,38 @@ strawbrary,strawberry strawbrerry,strawberry strawburries,strawberries strawburry,strawberry +strcture,structure +strctures,structures +strcutre,structure +strcutural,structural +strcuture,structure +strcutures,structures streaching,stretching streamade,streamed streamare,streamer streamd,streamed streamear,streamer streames,streams +streamm,stream +streammed,streamed +streamming,streaming streamos,streams streamtrue,streamer streamus,streams streamys,streams +streatched,stretched +strech,stretch +streched,stretched +streches,stretches +streching,stretching strechted,stretched strechtes,stretches strechting,stretching +strectch,stretch strecthed,stretched strecthes,stretches strecthing,stretching +streem,stream streemlining,streamlining stregnth,strength stregnthen,strengthen @@ -24465,6 +45553,8 @@ stregnths,strengths stregth,strength streichung,stretching streightened,straightened +strem,stream +strema,stream stremear,streamer strengh,strength strenghen,strengthen @@ -24476,6 +45566,7 @@ strenghtend,strengthen strenghtened,strengthened strenghtening,strengthening strenghtens,strengthen +strenghts,strengths strengsten,strengthen strengtened,strengthened strengtheing,strengthening @@ -24487,7 +45578,9 @@ strengts,strengths strenous,strenuous strentgh,strength strentghs,strengths +strenth,strength streoid,steroid +strerrror,strerror stressade,stressed stressende,stressed stressers,stresses @@ -24496,55 +45589,123 @@ stretchs,stretches stretegically,strategically striaght,straight striaghten,straighten +striaghtens,straightens striaghtforward,straightforward +striaghts,straights strians,strains striclty,strictly +stricly,strictly +stricteir,stricter +strictier,stricter +strictiest,strictest strictist,strictest stricty,strictly striekr,striker striekrs,strikers +strig,string +strigification,stringification +strigifying,stringifying strikely,strikingly stringet,stringent +stringifed,stringified stringnet,stringent +strinsg,strings +strippen,stripped +stript,stripped +strirngification,stringification strnad,strand +strng,string +stroage,storage +stroe,store +stroing,storing stromed,stormed stromfront,stormfront stronkhold,stronghold -stroy,story +stronlgy,strongly +stronly,strongly +strore,store +strored,stored +strores,stores +stroring,storing +strotage,storage +stroy,story,destroy stroyline,storyline stroylines,storylines stroytelling,storytelling +struc,struct +strucrure,structure +strucrured,structured +strucrures,structures +structed,structured +structer,structure +structere,structure structered,structured +structeres,structures +structire,structure +structre,structure +structred,structured +structres,structures structrual,structural structual,structural +structue,structure +structued,structured +structues,structures +structur,structure structurel,structural structurels,structures structurs,structures +strucure,structure strucutral,structural strucutre,structure strucutred,structured strucutres,structures +strucuture,structure +struggel,struggle struggeld,struggled +struggeled,struggled +struggeling,struggling struggels,struggles strugglebus,struggles struggleing,struggling strugglign,struggling +struttural,structural +strutture,structure +struture,structure strwaberry,strawberry stryofoam,styrofoam +ststr,strstr +stteting,setting +sttetings,settings +stting,string,setting,sitting +sttings,strings,settings,sittings sttutering,stuttering +stuation,situation,station +stuations,situations,stations stubbon,stubborn stubborness,stubbornness stubbron,stubborn stubmled,stumbled +stucked,stuck +stuckt,stuck +stuct,struct +stucts,structs stucture,structure stuctured,structured +stuctures,structures studdy,study +studi,study,studio studing,studying studioes,studios +studis,studies,studios +studoi,studio +studois,studios stuggling,struggling +stuido,studio stuidos,studios +stuill,still stuipder,stupider stumbeld,stumbled +stummac,stomach stunami,tsunami stupdily,stupidly stupidfree,stupider @@ -24560,7 +45721,15 @@ sturctures,structures sturggled,struggled sturggles,struggles sturggling,struggling +sturture,structure +sturtured,structured +sturtures,structures +sturucture,structure +stutdown,shutdown stutterring,stuttering +stutus,status +styhe,style +styilistic,stylistic stylisch,stylish styrofaom,styrofoam styrofom,styrofoam @@ -24570,6 +45739,10 @@ subarmine,submarine subarmines,submarines subcatagories,subcategories subcatagory,subcategory +subcirucit,subcircuit +subcommannd,subcommand +subcommnad,subcommand +subconchus,subconscious subconcsious,subconscious subconcsiously,subconsciously subconsciosly,subconsciously @@ -24580,14 +45753,44 @@ subconsicous,subconscious subconsicously,subconsciously subconsiously,subconsciously subcouncious,subconscious +subcribe,subscribe +subcribed,subscribed +subcribes,subscribes +subcribing,subscribing subcsription,subscriptions subculter,subculture subcultuur,subculture +subdirectoires,subdirectories +subdirectorys,subdirectories +subdirecty,subdirectory +subdivisio,subdivision +subdivisiond,subdivisioned +subdoamin,subdomain +subdoamins,subdomains +subelemet,subelement +subelemets,subelements subesquent,subsequent subesquently,subsequently +subexperesion,subexpression +subexperesions,subexpressions +subexperession,subexpression +subexperessions,subexpressions +subexpersion,subexpression +subexpersions,subexpressions +subexperssion,subexpression +subexperssions,subexpressions +subexpession,subexpression +subexpessions,subexpressions +subexpresssion,subexpression +subexpresssions,subexpressions +subfolfer,subfolder +subfolfers,subfolders +subfroms,subforms +subirectory,subdirectory subisdized,subsidized subisdizing,subsidizing subisdy,subsidy +subjec,subject subjectief,subjective subjectifs,subjects subjectivelly,subjectively @@ -24598,7 +45801,14 @@ subjectivly,subjectively subjectivy,subjectively subjektive,subjective subjest,subjects +subjet,subject subjudgation,subjugation +sublass,subclass +sublasse,subclasse +sublasses,subclasses +sublcasses,subclasses +sublcuase,subclause +suble,subtle subltety,subtlety submachne,submachine submarie,submarines @@ -24607,21 +45817,98 @@ submarinas,submarines submergerd,submerged submergered,submerged submerines,submarines +submision,submission submisison,submissions submisisons,submissions submissies,submissive +submisson,submission submissons,submissions +submited,submitted +submition,submission +submitions,submissions submittion,submitting +submittted,submitted +submoule,submodule +submti,submit +subnegatiotiation,subnegotiation +subnegatiotiations,subnegotiations +subnegoatiation,subnegotiation +subnegoatiations,subnegotiations +subnegoation,subnegotiation +subnegoations,subnegotiations +subnegociation,subnegotiation +subnegociations,subnegotiations +subnegogtiation,subnegotiation +subnegogtiations,subnegotiations +subnegoitation,subnegotiation +subnegoitations,subnegotiations +subnegoptionsotiation,subnegotiation +subnegoptionsotiations,subnegotiations +subnegosiation,subnegotiation +subnegosiations,subnegotiations +subnegotaiation,subnegotiation +subnegotaiations,subnegotiations +subnegotaition,subnegotiation +subnegotaitions,subnegotiations +subnegotatiation,subnegotiation +subnegotatiations,subnegotiations +subnegotation,subnegotiation +subnegotations,subnegotiations +subnegothiation,subnegotiation +subnegothiations,subnegotiations +subnegotication,subnegotiation +subnegotications,subnegotiations +subnegotioation,subnegotiation +subnegotioations,subnegotiations +subnegotion,subnegotiation +subnegotionation,subnegotiation +subnegotionations,subnegotiations +subnegotions,subnegotiations +subnegotiotation,subnegotiation +subnegotiotations,subnegotiations +subnegotiotion,subnegotiation +subnegotiotions,subnegotiations +subnegotitaion,subnegotiation +subnegotitaions,subnegotiations +subnegotitation,subnegotiation +subnegotitations,subnegotiations +subnegotition,subnegotiation +subnegotitions,subnegotiations +subnegoziation,subnegotiation +subnegoziations,subnegotiations +subobjecs,subobjects +suboutine,subroutine +subpackge,subpackage +subpackges,subpackages subpecies,subspecies +subporgram,subprogram +subproccese,subprocess +subpsace,subspace +subquue,subqueue +subract,subtract +subracted,subtracted +subraction,subtraction subredddits,subreddits subredditors,subreddits +subree,subtree +subroutie,subroutine +subrouties,subroutines subruban,suburban subsadized,subsidized +subsceptible,susceptible +subscibe,subscribe +subscibed,subscribed +subsciber,subscriber +subscibers,subscribers subscirbe,subscribe subscirbed,subscribed -subscirber,subscribers +subscirber,subscribers,subscriber subscirbers,subscribers -subscirption,subscriptions +subscirbes,subscribes +subscirbing,subscribing +subscirpt,subscript +subscirption,subscriptions,subscription +subscirptions,subscriptions subsconcious,subconscious subsconciously,subconsciously subscribar,subscriber @@ -24640,13 +45927,29 @@ subscriping,subscribing subscriptin,subscriptions subscripton,subscription subscriptons,subscriptions -subscritpion,subscriptions +subscritpion,subscriptions,subscription +subscritpions,subscriptions +subscritpiton,subscription +subscritpitons,subscriptions +subscritpt,subscript +subscritption,subscription +subscritptions,subscriptions subscrpition,subscriptions subscrubed,subscribed subscryber,subscriber +subsecrion,subsection +subsedent,subsequent subsedized,subsidized +subseqence,subsequence +subseqent,subsequent subsequant,subsequent subsequenty,subsequently +subsequest,subsequent +subsequnce,subsequence +subsequnt,subsequent +subsequntly,subsequently +subshystem,subsystem +subshystems,subsystems subsidary,subsidiary subsidezed,subsidized subsidiced,subsidized @@ -24660,6 +45963,22 @@ subsiduary,subsidiary subsiquent,subsequent subsiquently,subsequently subsittute,substitutes +subsituent,substituent +subsituents,substituents +subsitutable,substitutable +subsitutatble,substitutable +subsitute,substitute +subsituted,substituted +subsitutes,substitutes +subsituting,substituting +subsitution,substitution +subsitutuent,substituent +subsitutuents,substituents +subsitutute,substitute +subsitututed,substituted +subsitututes,substitutes +subsitututing,substituting +subsitutution,substitution subsizide,subsidize subsizided,subsidized subsiziding,subsidizing @@ -24669,8 +45988,11 @@ subsrcibe,subscribe subsrcibed,subscribed subsrcibers,subscribers subsrciption,subscriptions +subsriber,subscriber subsricption,subscriptions substace,substance +substact,subtract +substaintially,substantially substancial,substantial substancially,substantially substanial,substantial @@ -24697,18 +46019,26 @@ substatial,substantial substences,substances substential,substantial substite,substitute +substition,substitution +substitions,substitutions substitite,substitute substitition,substitution +substititions,substitutions substitiute,substitute substittue,substitutes +substituation,substitution +substituations,substitutions substitude,substitute substituded,substituted substitudes,substitutes +substituding,substituting substitue,substitute -substitued,substitute +substitued,substitute,substituted substituer,substitute substitues,substitutes +substituing,substituting substituion,substitution +substituions,substitutions substiture,substitute substitures,substitutes substitutents,substitutes @@ -24720,14 +46050,28 @@ substitutos,substitutes substituts,substitutes substitutue,substitutes substitutues,substitutes +substiution,substitution substract,subtract substracted,subtracted substracting,subtracting substraction,subtraction substracts,subtracts -substutite,substitutes +substucture,substructure +substuctures,substructures +substutite,substitutes,substitute subsudized,subsidized +subsysthem,subsystem +subsysthems,subsystems +subsystyem,subsystem +subsystyems,subsystems +subsysytem,subsystem +subsysytems,subsystems +subsytem,subsystem +subsytems,subsystems +subtabels,subtables subtances,substances +subtarger,subtarget +subtargers,subtargets subtelty,subtlety subterranian,subterranean subtetly,subtlety @@ -24738,74 +46082,174 @@ subtitel,subtitle subtitels,subtitles subtitls,subtitles subtitltes,subtitle +subtitute,substitute +subtituted,substituted +subtitutes,substitutes +subtituting,substituting +subtitution,substitution +subtitutions,substitutions subtletly,subtlety subtltey,subtlety subtlties,subtitles +subtrafuge,subterfuge +subtring,substring +subtrings,substrings +subtsitutable,substitutable +subtsitutatble,substitutable suburburban,suburban +subystem,subsystem +subystems,subsystems succceeded,succeeded +succcess,success succcesses,successes +succcessful,successful +succcessfully,successfully +succcessor,successor +succcessors,successors +succcessul,successful +succcessully,successfully +succecful,successful +succed,succeed +succedd,succeed succedded,succeeded +succedding,succeeding +succedds,succeeds succede,succeed succeded,succeeded succedes,succeeds +succedfully,successfully +succeding,succeeding succeds,succeeds succeedes,succeeds -succeeed,succeed -succees,succeeds +succeeed,succeed,succeeded +succees,succeeds,success +succes,success succesd,succeeds succesed,succeeds succesful,successful +succesfull,successful succesfully,successfully succesfuly,successfully succesion,succession succesions,succession succesive,successive +succesor,successor +succesors,successors +successed,succeeded,success,successful successeurs,successes +successfule,successful successfull,successful +successfullies,successfully successfullly,successfully +successfulln,successful +successfullness,successfulness +successfullt,successfully successfuly,successfully -successing,succession +successing,succession,successive successivo,succession -successs,successes +successs,successes,success +successsfully,successfully successsion,succession +successul,successful successully,successfully +succint,succinct +succseeded,succeeded succsesfull,successfully succsess,success succsessfull,successful +succsessive,successive suceed,succeed suceeded,succeeded suceeding,succeeding suceeds,succeeds +suces,success +suceses,successes sucesful,successful +sucesfull,successful sucesfully,successfully sucesfuly,successfully sucesion,succession +sucesive,successive sucess,success +sucesscient,sufficient +sucessed,succeeded +sucesseding,succeeding,seceding +sucessefully,successfully sucesses,successes +sucessess,success +sucessflly,successfully +sucessfually,successfully +sucessfukk,successful sucessful,successful sucessfull,successful sucessfully,successfully sucessfuly,successfully sucession,succession +sucessiv,successive sucessive,successive +sucessively,successively sucessor,successor +sucessors,successors sucessot,successor +sucesss,success +sucessses,successes +sucesssful,successful +sucesssfull,successful +sucesssfully,successfully +sucesssfuly,successfully +sucessufll,successful +sucessuflly,successfully +sucessully,successfully sucide,suicide sucidial,suicidal +sucome,succumb +sucsede,succeed sucseptible,susceptible suddeny,suddenly suddnely,suddenly +sudent,student +sudents,students +sudmobule,submodule +sudmobules,submodules sudnerland,sunderland +sueful,useful suefull,usefull +suface,surface +sufaces,surfaces +sufface,surface +suffaces,surfaces sufferage,suffrage sufferd,suffered sufferered,suffered sufferred,suffered sufferring,suffering +sufficate,suffocate +sufficated,suffocated +sufficates,suffocates +sufficating,suffocating +suffication,suffocation sufficent,sufficient sufficently,sufficiently sufficiant,sufficient sufficit,sufficient +suffisticated,sophisticated +suficate,suffocate +suficated,suffocated +suficates,suffocates +suficating,suffocating +sufication,suffocation +suficcient,sufficient +suficient,sufficient +suficiently,sufficiently +sufocate,suffocate +sufocated,suffocated +sufocates,suffocates +sufocating,suffocating +sufocation,suffocation +sugested,suggested +sugestion,suggestion +sugestions,suggestions +sugests,suggests suggesst,suggests suggeste,suggestive suggestes,suggests @@ -24814,22 +46258,57 @@ suggestied,suggestive suggestief,suggestive suggestieve,suggestive suggestons,suggests +suggestsed,suggested +suggestted,suggested +suggesttion,suggestion +suggesttions,suggestions +sugget,suggest +suggeted,suggested +suggets,suggest,suggests +suggetsed,suggested +suggetsing,suggesting +suggetsion,suggestion +sugggest,suggest +sugggested,suggested +sugggesting,suggesting +sugggestion,suggestion +sugggestions,suggestions +sugguest,suggest +sugguested,suggested +sugguesting,suggesting +sugguestion,suggestion +sugguestions,suggestions +suh,such +suiete,suite +suiteable,suitable +sumamry,summary sumary,summary sumbarine,submarine sumbarines,submarines sumberged,submerged sumbissions,submissions sumbissive,submissive +sumbitted,submitted sumbitting,submitting +summay,summary summenor,summoner summenors,summoners +summerised,summarised summerized,summarized +summersalt,somersault +summmaries,summaries +summmarisation,summarisation +summmarised,summarised +summmarization,summarization +summmarized,summarized +summmary,summary summoenrs,summoners summones,summoners summonr,summoner summore,summoner summorized,summarized summurized,summarized +sumodules,submodules sunconscious,subconscious sunconsciously,subconsciously sunderlad,sunderland @@ -24845,10 +46324,23 @@ sunglinger,gunslinger sunifre,sunfire sunscreeen,sunscreen sunscren,sunscreen +suntask,subtask suop,soup +supeblock,superblock +supeena,subpoena +supercalifragilisticexpialidoceous,supercalifragilisticexpialidocious +supercede,supersede +superceded,superseded +supercedes,supersedes +superceding,superseding +superceed,supersede superceeded,superseded superfical,superficial superficiel,superficial +superflouous,superfluous +superflous,superfluous +superflouse,superfluous +superfluious,superfluous superfluos,superfluous superfluu,superfluous superfulous,superfluous @@ -24885,9 +46377,14 @@ superme,supreme supernarkets,supermarkets supernatrual,supernatural supernatual,supernatural +superopeator,superoperator superouman,superhuman superposer,superpowers superpowereds,superpowers +supersed,superseded +superseedd,superseded +superseede,supersede +superseeded,superseded supersition,supervision supersticion,superstition supersticious,superstitious @@ -24914,15 +46411,30 @@ supervisores,supervisors supervsior,supervisors suphisticated,sophisticated supirsed,surprised +suplant,supplant +suplanted,supplanted +suplanting,supplanting +suplants,supplants +suplementary,supplementary +suplied,supplied suplimented,supplemented supllemental,supplemental +supllies,supplies suport,support +suported,supported +suporting,supporting +suports,supports +suportted,supported supose,suppose suposed,supposed suposedly,supposedly suposes,supposes suposing,supposing +suposse,suppose supperssor,suppressor +suppied,supplied +suppier,supplier +suppies,supplies supplament,supplement supplamental,supplemental supplamented,supplemented @@ -24930,48 +46442,97 @@ supplaments,supplements supplemant,supplemental supplemetal,supplemental supplemets,supplements +suppliad,supplied suppliementing,supplementing +suppliment,supplement supplimental,supplemental suppoed,supposed +suppoert,support +suppoort,support +suppoorts,supports +suppopose,suppose +suppoprt,support +suppoprted,supported +suppor,support +suppored,supported +supporession,suppression supporre,supporters supportare,supporters +supportd,supported +supporte,supported,supporter supportes,supports +supportet,supporter,supported supporteur,supporter supporteurs,supporters supportied,supported +supportin,supporting supportors,supporters +supportted,supported supposdely,supposedly supposebly,supposedly +supposeded,supposed supposedely,supposedly +supposeds,supposed +supposedy,supposedly supposidely,supposedly supposidly,supposedly supposingly,supposedly +suppossed,supposed suppost,supports +suppoted,supported +suppplied,supplied +suppport,support +suppported,supported +suppporting,supporting +suppports,supports +suppres,suppress suppreses,suppress suppresion,suppression suppresions,suppression suppresors,suppressor suppressin,suppression +suppressingd,suppressing suppressio,suppressor suppresson,suppression suppresssion,suppression suppresssor,suppressor +supprot,support +supproted,supported +supproter,supporter +supproters,supporters +supproting,supporting +supprots,supports +supprt,support +supprted,supported suppy,supply +suppying,supplying supramacist,supremacist suprass,surpass suprassing,surpassing supremacits,supremacist supremasist,supremacist supremicist,supremacist +supres,suppress +supresed,suppressed +supreses,suppresses +supresing,suppressing +supresion,suppression supress,suppress supressed,suppressed supresses,suppresses +supressible,suppressible supressing,suppressing supression,suppression +supressions,suppressions +supressor,suppressor +supressors,suppressors +supresssion,suppression suprimacist,supremacist +suprious,spurious suprisd,surprised suprise,surprise suprised,surprised +suprises,surprises suprising,surprising suprisingly,surprisingly suprize,surprise @@ -24989,9 +46550,19 @@ supsicion,suspicion supsicions,suspicions supsicious,suspicious supsiciously,suspiciously +supspect,suspect +supspected,suspected +supspecting,suspecting +supspects,suspects +surbert,sherbert surbuban,suburban surfce,surface -surley,surly +surgest,suggest +surgested,suggested +surgestion,suggestion +surgestions,suggestions +surgests,suggests +surley,surly,surely suround,surround surounded,surrounded surounding,surrounding @@ -25000,20 +46571,30 @@ surounds,surrounds surpases,surpass surpemacist,supremacist surpeme,supreme +surpise,surprise +surpises,surprises surplanted,supplanted +surport,support +surported,supported surpress,suppress surpressed,suppressed +surpresses,suppresses +surpressing,suppressing +surprisinlgy,surprisingly surprisinly,surprisingly surprize,surprise surprized,surprised surprizing,surprising surprizingly,surprisingly +surregat,surrogate +surrended,surrounded,surrendered surrenderd,surrendered surrenderred,surrendered surrepetitious,surreptitious surrepetitiously,surreptitiously surreptious,surreptitious surreptiously,surreptitiously +surrogage,surrogate surronded,surrounded surroud,surround surrouded,surrounded @@ -25026,17 +46607,22 @@ surroundins,surrounds surroundngs,surrounds surrouned,surround surrouns,surrounds +surrrounded,surrounded surrundering,surrendering survaillance,surveillance survaillence,surveillance survallience,surveillance survavibility,survivability +survay,survey +survays,surveys surveilence,surveillance surveill,surveil surveillence,surveillance survelliance,surveillance surveyer,surveyor survibability,survivability +survice,service,survive +survices,services,survives surviellance,surveillance survivabiity,survivability survivabililty,survivability @@ -25054,6 +46640,10 @@ survivied,survived survivour,survivor survivours,survivor susbcribe,subscribe +susbsystem,subsystem +susbsystems,subsystems +susbsytem,subsystem +susbsytems,subsystems susbtantial,substantial susbtantially,substantially susbtantive,substantive @@ -25063,24 +46653,34 @@ susceptable,susceptible susceptiable,susceptible susceptibile,susceptible suscpetible,susceptible +suscribe,subscribe +suscribed,subscribed +suscribes,subscribes +suscript,subscript susecptible,susceptible +susepect,suspect suseptable,susceptible suseptible,susceptible +susinctly,succinctly +susinkt,succinct susncreen,sunscreen suspecions,suspicions suspecious,suspicious suspeciously,suspiciously suspectes,suspects suspectible,susceptible +suspedn,suspend suspencion,suspension suspendeds,suspense suspendes,suspense suspened,suspend +suspeneded,suspended suspensie,suspense suspenso,suspension suspention,suspension suspicians,suspicions suspiciois,suspicions +suspicios,suspicious suspiciosly,suspiciously suspicioso,suspicions suspicioulsy,suspiciously @@ -25092,27 +46692,63 @@ suspicison,suspicions suspicisons,suspicions suspiciuos,suspicions suspiciuosly,suspiciously +suspicous,suspicious +suspicously,suspiciously suspicsion,suspicions +suspision,suspicion suspisions,suspicions suspisious,suspicious suspisiously,suspiciously suspitions,suspicions +suspsend,suspend +sussinct,succinct sustainabillity,sustainability sustainabiltiy,sustainability sustainabilty,sustainability sustainabily,sustainability sustainble,sustainable sustainible,sustainable +sustem,system +sustems,systems +sustitution,substitution +sustitutions,substitutions +susupend,suspend +sutable,suitable,stable +sutdown,shutdown +sute,site,suite,suit +sutisfaction,satisfaction +sutisfied,satisfied +sutisfies,satisfies +sutisfy,satisfy +sutisfying,satisfying +suttle,subtle,shuttle +suttled,shuttled +suttles,shuttles +suttlety,subtlety +suttling,shuttling +suuport,support +suuported,supported +suuporting,supporting +suuports,supports +suvenear,souvenir +svae,save,suave +svelt,svelte swaer,swear swaering,swearing swaers,swears swaetshirt,sweatshirt +swalloed,swallowed swansoon,swanson +swaped,swapped +swapiness,swappiness +swaping,swapping +swarmin,swarming swasitka,swastika swaskita,swastika swastikka,swastika swatiska,swastika swatsika,swastika +swcloumns,swcolumns swearengin,swearing swearshirt,sweatshirt sweathsirt,sweatshirt @@ -25126,29 +46762,91 @@ sweetheat,sweetheart sweetshart,sweetheart sweidsh,swedish swepth,swept +swich,switch +swiched,switched +swiching,switching +swicth,switch +swicthed,switched +swicthing,switching swiflty,swiftly swiftley,swiftly swiming,swimming switcheasy,switches switchign,switching switchs,switches +switchting,switching switerzland,switzerland switfly,swiftly +swith,switch +swithable,switchable +swithc,switch +swithcboard,switchboard swithced,switched swithces,switches +swithch,switch +swithches,switches +swithching,switching swithcing,switching +swithcover,switchover +swithed,switched +swithing,switching +switiches,switches switserland,switzerland switzerand,switzerland switzlerand,switzerland swizterland,switzerland swnasea,swansea +swown,shown +swtich,switch swtiched,switched swtiches,switches swtiching,switching +swtichs,switches swtizerland,switzerland +sxl,xsl +syantax,syntax syarcuse,syracuse syas,says +syatem,system +syatems,systems +sybsystem,subsystem +sybsystems,subsystems +sychronisation,synchronisation +sychronise,synchronise +sychronised,synchronised +sychroniser,synchroniser +sychronises,synchronises +sychronisly,synchronously +sychronization,synchronization +sychronize,synchronize +sychronized,synchronized +sychronizer,synchronizer +sychronizes,synchronizes +sychronmode,synchronmode +sychronous,synchronous +sychronously,synchronously +sycle,cycle +sycled,cycled +sycles,cycles +syclic,cyclic,psychic +syclical,cyclical,physical +sycling,cycling +sycn,sync sycning,syncing +sycology,psychology +sycronise,synchronise +sycronised,synchronised +sycronises,synchronises +sycronising,synchronising +sycronization,synchronization +sycronizations,synchronizations +sycronize,synchronize +sycronized,synchronized +sycronizes,synchronizes +sycronizing,synchronizing +sycronous,synchronous +sycronously,synchronously +sycronus,synchronous sycther,scyther sydnicate,syndicate sydnrome,syndrome @@ -25157,17 +46855,35 @@ sykwalker,skywalker sykward,skyward sylablle,syllable sylablles,syllables +sylabus,syllabus +sylabuses,syllabuses,syllabi +syle,style +syles,styles +sylibol,syllable +sylinder,cylinder +sylinders,cylinders syllabe,syllable syllabel,syllable syllabels,syllables +syllabills,syllabus,syllabification +sylog,syslog +symantics,semantics symapthetic,sympathetic symapthize,sympathize symapthizers,sympathizers symapthy,sympathy +symblic,symbolic +symbo,symbol symboles,symbols symbolisch,symbolic symbolisim,symbolism +symboll,symbol symbolsim,symbolism +symbsol,symbol +symbsols,symbols +symemetric,symmetric +symetri,symmetry +symetric,symmetric symetrical,symmetrical symetrically,symmetrically symetry,symmetry @@ -25175,14 +46891,22 @@ symettric,symmetric symhpony,symphony symmertical,symmetrical symmerty,symmetry +symmetic,symmetric symmetral,symmetric +symmetri,symmetry symmetria,symmetrical symmetricaly,symmetrically symmety,symmetry symmtery,symmetry +symnol,symbol +symnols,symbols +symobilic,symbolic +symobl,symbol symoblic,symbolic symoblism,symbolism symobls,symbols +symol,symbol +symols,symbols sympathatic,sympathetic sympatheic,sympathetic sympathethic,sympathetic @@ -25217,18 +46941,62 @@ symptoom,symptom symtpom,symptom symtpoms,symptoms synagouge,synagogue +synamic,dynamic +synax,syntax +synchonisation,synchronisation +synchonise,synchronise +synchonised,synchronised +synchonises,synchronises +synchonising,synchronising +synchonization,synchronization +synchonize,synchronize +synchonized,synchronized +synchonizes,synchronizes +synchonizing,synchronizing +synchonrous,synchronous synchornously,synchronously +synchrnization,synchronization +synchrnonization,synchronization +synchroizing,synchronizing +synchromized,synchronized +synchroneous,synchronous +synchroneously,synchronously +synchronious,synchronous +synchroniously,synchronously +synchronizaton,synchronization +synchronsouly,synchronously +synchronuous,synchronous +synchronuously,synchronously +synchronus,synchronous +syncrhonise,synchronise +syncrhonised,synchronised +syncrhonize,synchronize +syncrhonized,synchronized +syncronise,synchronise +syncronised,synchronised +syncronises,synchronises +syncronising,synchronising syncronization,synchronization +syncronizations,synchronizations +syncronize,synchronize +syncronized,synchronized +syncronizes,synchronizes +syncronizing,synchronizing syncronous,synchronous syncronously,synchronously +syncronus,synchronous +syncting,syncing syndacite,syndicate syndiacte,syndicate +syndonic,syntonic synegry,synergy synidcate,syndicate +synomym,synonym synomymous,synonymous synomynous,synonymous synomyns,synonyms synonamous,synonymous +synonim,synonym synonimous,synonymous synonmyous,synonymous synonmys,synonyms @@ -25242,15 +47010,40 @@ synonymos,synonymous synonymus,synonyms synonynous,synonymous synopsies,synopsis +synopsys,synopsis +synoym,synonym synoynm,synonym synoynms,synonyms synphony,symphony synposis,synopsis +synronous,synchronous +syntac,syntax +syntacks,syntax +syntacs,syntax +syntact,syntax +syntactally,syntactically +syntacts,syntax +syntak,syntax +syntaks,syntax +syntakt,syntax +syntakts,syntax +syntatic,syntactic +syntaxg,syntax syntehsis,synthesis +syntehsise,synthesise +syntehsised,synthesised +syntehsize,synthesize +syntehsized,synthesized syntehtic,synthetic +syntesis,synthesis syntethic,synthetic +syntetic,synthetic +syntetize,synthetize +syntetized,synthetized synthesasia,synthesis synthesesia,synthesis +synthethic,synthetic +synthtic,synthetic syphyllis,syphilis sypmathetic,sympathetic sypmathize,sympathize @@ -25258,6 +47051,7 @@ sypmathy,sympathy sypmtom,symptom sypmtoms,symptoms sypnosis,synopsis +sypport,support syracue,syracuse syracusae,syracuse syrains,syrians @@ -25268,9 +47062,18 @@ syringae,syringe syringue,syringe sysadmn,sysadmin sysamdin,sysadmin +sysbols,symbols +syschronize,synchronize sysdamin,sysadmin +sysem,system +sysematic,systematic +sysems,systems sysmatically,systematically +sysmbol,symbol +sysmograph,seismograph systamatic,systematic +systax,syntax +syste,system systematicaly,systematically systematiclly,systematically systematisch,systematic @@ -25278,15 +47081,61 @@ systemc,systemic systemetic,systematic systemetically,systematically systemisch,systemic +systemwindiow,systemwindow +systen,system +systens,systems +systhem,system +systhemerror,systemerror +systhemmemory,systemmemory +systhems,systems +systhemwindow,systemwindow systimatic,systematic systimatically,systematically +systm,system +systme,system +systmes,systems +systms,systems +systyem,system +systyems,systems +sysyem,system +sysyems,systems sytem,system +sytematic,systematic +sytemd,systemd +syteme,system +sytemerror,systemerror +sytemmemory,systemmemory +sytems,systems +sytemwindow,systemwindow +sythesis,synthesis sytle,style +sytled,styled +sytles,styles +sytlesheet,stylesheet +sytling,styling sytlish,stylish +sytnax,syntax +sytntax,syntax sytrofoam,styrofoam +szenario,scenario +szenarios,scenarios +szes,sizes +szie,size +szied,sized +szies,sizes tabacco,tobacco +tabbaray,taboret +tabblow,tableau +tabe,table +tabel,table +tabeles,tables +tabels,tables tabelspoon,tablespoon tabelspoons,tablespoons +tabeview,tabview +tabke,table +tablepsace,tablespace +tablepsaces,tablespaces tablepsoons,tablespoons tablespon,tablespoon tablespons,tablespoons @@ -25294,13 +47143,32 @@ tablespooon,tablespoon tablespooons,tablespoon tablesppon,tablespoon tablesppons,tablespoons +tablle,table +tabluar,tabular +tabluate,tabulate +tabluated,tabulated +tabluates,tabulates +tabluating,tabulating +tabualte,tabulate +tabualted,tabulated +tabualtes,tabulates +tabualting,tabulating +tabualtor,tabulator +tabualtors,tabulators tacitcally,tactically tacticallity,tactically tacticaly,tactically tacticas,tactics tacticts,tactics tacticus,tactics +tage,stage,take,tag,tagged +taged,tagged +taget,target +tagggen,taggen tagliate,tailgate +tagnet,tangent +tagnetial,tangential +tagnets,tangents tahn,than tahnkyou,thankyou taht,that @@ -25311,40 +47179,102 @@ tailord,tailored tailsman,talisman taiwanee,taiwanese taiwanesse,taiwanese +taks,task,tasks +takslet,tasklet +talbe,table talbian,taliban talekd,talked taligate,tailgate taligating,tailgating taliored,tailored tallents,tallest +tallerable,tolerable tallets,tallest talsiman,talisman +tamplate,template +tamplated,templated +tamplates,templates +tamplating,templating tanenhill,tannehill +tangeant,tangent +tangeantial,tangential +tangeants,tangents tangeld,tangled tangencially,tangentially tangenitally,tangentially +tangensial,tangential +tangentailly,tangentially tangentialy,tangentially +tanget,tangent +tangetial,tangential +tangetially,tangentially +tangets,tangents tangientally,tangentially tanlged,tangled tannheill,tannehill +tansact,transact +tansaction,transaction +tansactional,transactional +tansactions,transactions +tanseint,transient +tansfomed,transformed +tansient,transient +tanslate,translate +tanslated,translated +tanslates,translates +tanslation,translation +tanslations,translations +tanslator,translator +tansmit,transmit tantrumers,tantrums tanturms,tantrums tapitude,aptitude +tarbal,tarball +tarbals,tarballs +targed,target +targer,target targetd,targeted targetted,targeted targetting,targeting +targettting,targeting +targt,target +targte,target +tarmigan,ptarmigan +tarnsparent,transparent +tarpolin,tarpaulin +tarvis,travis +tarvisci,travisci taryvon,trayvon +tasbar,taskbar +taskelt,tasklet tasliman,talisman tast,taste tath,that tatoo,tattoo +tatoos,tattoos tattooes,tattoos tattooos,tattoos +taveled,traveled,traveled +taveling,traveling,traveling +tavelled,travelled,travelled +tavelling,travelling,travelling tawainese,taiwanese tawianese,taiwanese +tawk,talk taxanomic,taxonomic taxanomy,taxonomy +taxnomy,taxonomy +taxomonmy,taxonomy +taxonmy,taxonomy +taxonoy,taxonomy +taylored,tailored +tbe,the +tbey,they +tcahce,cache +tcahces,caches +tcheckout,checkout teached,taught +teachnig,teaching teamfighs,teamfights teamfighters,teamfights teamfigt,teamfight @@ -25352,6 +47282,8 @@ teamfigth,teamfight teamfigths,teamfights teamifght,teamfight teamifghts,teamfights +teamplate,template +teamplates,templates teampseak,teamspeak teamspeack,teamspeak teamspek,teamspeak @@ -25360,20 +47292,29 @@ teansylvania,transylvania teapsoon,teaspoon teaspon,teaspoon teaspooon,teaspoon +teated,treated techanically,mechanically techeis,techies +techical,technical techician,technician techicians,technicians +techincal,technical techincality,technicality techincally,technically techincian,technician techincians,technicians +techinically,technically techinican,technician +techinique,technique techiniques,techniques techinque,technique techinques,techniques +techique,technique +techiques,techniques techmological,technological techncially,technically +techneek,technique +technic,technique technicain,technician technicallity,technically technicalty,technicality @@ -25385,9 +47326,14 @@ technicials,technicians technicien,technician techniciens,technicians technicion,technician +technics,techniques +technik,technique +techniks,techniques techniqe,technique technitian,technician technitians,technicians +technition,technician +technlogy,technology technnology,technology technolgy,technology technoligical,technological @@ -25397,19 +47343,32 @@ technologial,technological technologicaly,technologically technologicially,technologically technologicly,technological +technoloiges,technologies technqiues,techniques techonlogical,technological techtician,technician techticians,technicians +tecnic,technique +tecnical,technical +tecnically,technically +tecnician,technician +tecnicians,technicians +tecnique,technique +tecniques,techniques +tedeous,tedious teeangers,teenagers teenages,teenagers +tefine,define teh,the tehcies,techies tehnically,ethnically tehtering,tethering tehy,they +tekst,text +teksts,texts telaportation,teleportation telegrah,telegraph +telegramm,telegram telegrapgh,telegraph telegrpah,telegraph telelevision,television @@ -25425,66 +47384,181 @@ televesion,television televisivo,television televsion,television teliportation,teleportation +telocom,telecom teloportation,teleportation telphony,telephony temafight,teamfight temafights,teamfights +temaplate,template +temaplates,templates temeprature,temperature temepratures,temperatures temepst,tempest temerature,temperature +teminate,terminate +teminated,terminated +teminating,terminating +temination,termination +temlate,template +temmporary,temporary,temporarily +temorarily,temporarily +temorary,temporary tempalrs,templars tempalte,template tempaltes,templates temparament,temperament +tempararily,temporarily +temparary,temporary temparate,temperate temparature,temperature temparatures,temperatures temparement,temperament +temparily,temporarily +tempate,template +tempated,templated +tempates,templates +tempatied,templatized +tempation,temptation +tempatised,templatised +tempatized,templatized +tempature,temperature +tempdate,template tempearture,temperatures +tempearure,temperature +tempelate,template tempels,temples temperamant,temperament temperarily,temporarily +temperarure,temperature +temperary,temporary temperatue,temperature temperatues,temperatures +temperatur,temperature temperaturas,temperatures temperaturs,temperatures temperatuur,temperature +tempereature,temperature temperement,temperament tempermeant,temperament temperment,temperament tempertaure,temperature temperture,temperature tempets,tempest +templaet,template templaras,templars templares,templars templarios,templars templarius,templars templas,templars +templat,template +templateas,templates templats,templates templeos,temples templers,temples +tempoaray,temporary +tempopary,temporary +temporaere,temporary +temporafy,temporary temporaily,temporarily temporairly,temporarily temporali,temporarily +temporalily,temporarily +temporaly,temporary,temporarily,temporally temporaraly,temporarily +temporarely,temporarily temporarilly,temporarily +temporarilty,temporarily +temporarilu,temporary +temporarirly,temporarily temporarity,temporarily -temporarly,temporary +temporarly,temporary,temporarily temporay,temporary -temprary,temporary +tempories,temporaries +temporily,temporarily +tempororaries,temporaries +tempororarily,temporarily +tempororary,temporary +temporories,temporaries +tempororily,temporarily +temporory,temporary +temporraies,temporaries +temporraily,temporarily +temporraries,temporaries +temporrarily,temporarily +temporrary,temporary +temporray,temporary +temporries,temporaries +temporrily,temporarily +temporry,temporary +temportal,temporal +temportaries,temporaries +temportarily,temporarily +temportary,temporary +tempory,temporary +temporyries,temporaries +temporyrily,temporarily +temporyry,temporary +tempraaily,temporarily +tempraal,temporal +tempraarily,temporarily +tempraarly,temporarily +tempraary,temporary +tempraay,temporary +tempraily,temporarily +tempral,temporal +temprament,temperament +tempramental,temperamental +tempraraily,temporarily +tempraral,temporal +tempraraly,temporarily,temporally +temprararily,temporarily +temprararly,temporarily +temprarary,temporary +tempraray,temporary +temprarily,temporarily +temprary,temporary,temporarily +temprature,temperature +tempratures,temperatures +tempray,temporary tempreature,temperature tempreatures,temperatures +temprement,temperament +tempremental,temperamental +temproaily,temporarily +temproal,temporal temproarily,temporarily +temproarly,temporarily +temproary,temporary +temproay,temporary +temproily,temporarily,temporally +temprol,temporal +temproment,temperament +tempromental,temperamental +temproraily,temporarily +temproral,temporal +temproraly,temporarily +temprorarily,temporarily +temprorarly,temporarily +temprorary,temporary +temproray,temporary +temprorily,temporarily +temprory,temporary +temproy,temporary tempset,tempest +temptatation,temptation temptating,temptation temptetion,temptation tempurature,temperature tempuratures,temperatures +tempurture,temperature +temr,term +temtation,temptation tenacitiy,tenacity tenacle,tentacle tenacles,tentacles tenactiy,tenacity +tenative,tentative +tenatively,tentatively tencaity,tenacity tendacy,tendency tendancies,tendencies @@ -25504,14 +47578,22 @@ tentacreul,tentacle tentacuel,tentacle tentalce,tentacle tentalces,tentacles +tention,tension +teplmate,template +teplmated,templated +teplmates,templates tepmorarily,temporarily tequilia,tequila tequlia,tequila +teridactyl,pterodactyl +terific,terrific +terimnate,terminate termanator,terminator termanology,terminology termendous,tremendous termendously,tremendously termianls,terminals +termianted,terminated termiantor,terminator termigator,terminator terminacion,termination @@ -25523,15 +47605,37 @@ terminarla,terminal terminarlo,terminal terminaron,terminator terminater,terminator +terminaters,terminators terminatior,terminator terminato,termination terminatorn,termination +terminats,terminates +termindate,terminate +termine,determine +termined,terminated terminilogy,terminology terminolgy,terminology terminoligy,terminology +terminte,terminate +termo,thermo +termostat,thermostat +termperatue,temperature +termperatues,temperatures +termperature,temperature +termperatures,temperatures +termplate,template +termplated,templated +termplates,templates +termporal,temporal +termporaries,temporaries +termporarily,temporarily +termporary,temporary +ternament,tournament +ternimate,terminate terorrism,terrorism terorrist,terrorist terorrists,terrorists +terrable,terrible terrabyte,terabyte terratorial,territorial terratories,territories @@ -25571,11 +47675,31 @@ terrorsits,terrorists terrotorial,territorial terrotories,territories terrurists,terrorists +tescase,testcase +tescases,testcases +tese,these +tesed,used,teased +tesellate,tessellate +tesellated,tessellated +tesellation,tessellation +tesellator,tessellator tesitcle,testicle tesitcles,testicles tesitfy,testify tesitmony,testimony +tessealte,tessellate +tessealted,tessellated +tesselatad,tessellated +tesselate,tessellate +tesselated,tessellated +tesselation,tessellation +tesselator,tessellator +tessleate,tessellate +tessleated,tessellated +tessleating,tessellating +tessleator,tessellator testasterone,testosterone +testeing,testing testestorone,testosterone testice,testicle testicel,testicle @@ -25585,12 +47709,27 @@ testiclies,testicle testiclular,testicular testifiy,testify testimoney,testimony +testin,testing +testng,testing testomony,testimony +tetrahedran,tetrahedron +tetrahedrans,tetrahedrons +tetry,retry +tetss,tests +tetxture,texture teusday,tuesday teusdays,tuesdays +texchnically,technically +texline,textline +textfrme,textframe texturers,textures +texual,textual +texually,textually texutres,textures +texxt,text +tey,they tghe,the +tha,than,that,the thaliand,thailand thankfullly,thankfully thankfuly,thankfully @@ -25598,25 +47737,53 @@ thanksgivng,thanksgiving thankyooou,thankyou thankyoou,thankyou thankyu,thankyou +thann,than,thank +thansk,thanks thanskgiving,thanksgiving +thansparent,transparent +thant,than +thare,there thast,that +thatn,that,than +thay,they +thck,thick +theard,thread +thearding,threading +theards,threads +theared,threaded thearpy,therapy theather,theater theathre,theatre theature,theatre +theef,thief +theer,there +theery,theory theese,these +thefore,therefore +thei,their,they theif,thief +theifs,thieves +theire,their +theis,this,thesis theisitc,theistic theistc,theistic +theiv,thief +theive,thief theives,thieves +themplate,template themsef,themself +themselces,themselves +themselfe,themselves,themself themselfes,themselves themselfs,themselves +themselve,themselves,themself themselvs,themselves themsevles,themselves themslef,themself themsleves,themselves themslves,themselves +thenes,themes +thenn,then theocracry,theocracy theoligical,theological theologia,theological @@ -25624,12 +47791,16 @@ theologial,theological theologicial,theological theoratical,theoretical theoratically,theoretically +theorectical,theoretical +theoreticall,theoretically theoreticaly,theoretically theoreticly,theoretical +theorical,theoretical +theorically,theoretically theoritical,theoretical theoritically,theoretically theorits,theorist -ther,there,their,the +ther,there,their,the,other therafter,thereafter therapautic,therapeutic therapetic,therapeutic @@ -25637,22 +47808,30 @@ therapeudic,therapeutic therapeutisch,therapeutic therapeutuc,therapeutic theraphy,therapy +therapudic,therapeutic therapuetic,therapeutic theraupetic,therapeutic therby,thereby +thereads,threads thereaputic,therapeutic therefo,thereof therefoer,therefor therefour,therefor thereian,therein +therem,there,theorem +thereom,theorem thereotical,theoretical thereotically,theoretically therepeutic,therapeutic therepists,therapists -theri,their +thererin,therein +therfore,therefore +theri,their,there therien,therein theripists,therapists thermastat,thermostat +thermisor,thermistor +thermisors,thermistors thermistat,thermostat thermodinamics,thermodynamics thermodyanmics,thermodynamics @@ -25672,6 +47851,8 @@ thermomoter,thermometer thermomter,thermometer thermoneter,thermometer thermostaat,thermostat +thermostast,thermostat +thermostasts,thermostats thernodynamics,thermodynamics theroem,theorem theroetical,theoretical @@ -25681,31 +47862,74 @@ theroist,theorist theroists,theorists theromdynamics,thermodynamics theromstat,thermostat +therough,through,thorough +therstat,thermostat +thes,this,these +theshold,threshold +thesholds,thresholds thesitic,theistic thesits,theists +thess,this,these +thest,test thetering,tethering +thether,tether,whether +thetrahedron,tetrahedron +thev,the +theves,thieves +thex,the,then +theyr,their,there +theyre,their,there thgat,that thge,the +thi,the,this thialand,thailand +thicking,thinking,thickening +thicknes,thickness,thickens +thid,this +thie,the,this thier,their thiestic,theistic thiests,theists +thight,tight,thigh,fight +thights,tights,thighs,fights thign,thing thigns,things +thigny,thingy thigsn,things +thik,thick,think thikn,think -thikning,thinking +thikness,thickness +thiknesses,thicknesses +thikning,thinking,thickening thikns,thinks +thiks,thinks +thime,time,theme,thyme,thine +thimngs,things +thinigs,things +thinkabel,thinkable +thinkg,think,thing,things +thinkgs,thinks,things +thinn,thin thirites,thirties thirldy,thirdly thirlling,thrilling +thirs,third,thirst thirstay,thirsty thirteeen,thirteen thirten,thirteen thirtsy,thirsty +thirtyth,thirtieth +thise,these,this +thisle,thistle +thist,this +thisy,this thiunk,think +thjese,these +thme,them thn,then thna,than +thnak,thank +thnaks,thanks thnakyou,thankyou thne,then thnig,thing @@ -25718,31 +47942,65 @@ thoeries,theories thoerist,theorist thoerists,theorists thomspon,thompson +thonic,chthonic thopmson,thompson thorats,throats thornes,thrones thoroughy,thoroughly thorttling,throttling +thorugh,through,thorough thorughout,throughout thoruim,thorium +thoruoghly,thoroughly +thorwn,thrown,thorn +thos,those,this +thoses,those thoughout,throughout thoughs,thoughts +thougt,thought,though +thougth,thought thougths,thoughts +thounsands,thousands thourogh,thorough thouroghly,thoroughly +thourough,thorough +thouroughly,thoroughly +thow,throw,tow +thown,thrown,town +thq,the +thrad,thread +thre,three,there,their,the threadd,threaded threadened,threaded +threadsave,threadsafe +threah,thread,threat +threashold,threshold +threasholds,thresholds threataning,threatening threatend,threatened threatended,threatened threatenes,threatens threates,threatens threatining,threatening +threatment,treatment +threatments,treatments threatning,threatening +thred,thread +threded,threaded +thredhold,threshold +threding,threading +threds,threads threee,three threefor,therefor threeof,thereof +threhold,threshold +threre,there,three +threrefore,therefore threshhold,threshold +threshholds,thresholds +threshol,threshold +thresold,threshold +thresshold,threshold thrid,third thridly,thirdly thristy,thirsty @@ -25750,32 +48008,63 @@ thriteen,thirteen thrities,thirties throast,throats throaths,throats +throen,thrown +throgh,through throium,thorium +thron,thrown,throne throners,thrones throough,thorough throrough,thorough throthling,throttling throtlling,throttling +throtte,throttle,trot +throtted,throttled,trotted +throttes,throttles,trots +throtting,throttling,trotting throttleing,throttling +throttoling,throttling +throug,through +througg,through throughiut,throughput throughly,thoroughly throughoput,throughput -throught,thought +throught,thought,through,throughout throughtout,throughout throughtput,throughput througout,throughout +througt,through +througth,through +throuh,through +throuth,through +throwed,threw,thrown +throwgh,through +thrue,thru +thruogh,through +thruoghout,throughout +thruoghput,throughput +thruout,throughout thrusday,thursday thrusdays,thursdays thryoid,thyroid +ths,the,this +thses,these thsi,this thsoe,those +thsose,those +thsould,should +thst,that +tht,the,that thta,that +thtat,that +thte,the,that thubmnails,thumbnails thudnerbolt,thunderbolt +thumbbnail,thumbnail thumbmails,thumbnails thumbnailers,thumbnails thumbnal,thumbnails thunberbolt,thunderbolt +thundebird,thunderbird thunderblot,thunderbolt thunderboat,thunderbolt thunderboldt,thunderbolt @@ -25785,30 +48074,83 @@ thunderbowl,thunderbolt thunderjolt,thunderbolt thunderolt,thunderbolt thundervolt,thunderbolt +thur,their thurdsay,thursday thurdsays,thursdays +thurough,thorough +thurrow,thorough thursdsay,thursdays thursdsy,thursdays thursters,thrusters +thurver,further +thw,the,thaw thyat,that thyorid,thyroid thyriod,thyroid tiawanese,taiwanese -tiem,time +tich,thick,tick,titch,stitch +tichened,thickened +tichness,thickness +tieing,tying +tiem,time,item +tiemout,timeout +tiemstamp,timestamp +tieth,tithe +tigger,trigger +tiggered,triggered +tiggering,triggering +tiggers,triggers tighetning,tightening +tighly,tightly tightare,tighter +tightely,tightly tightenting,tightening tightining,tightening +tigth,tight +tigthen,tighten +tigthened,tightened tigthening,tightening +tigthens,tightens tigther,tighter +tigthly,tightly tihkn,think tihs,this +timedlta,timedelta +timeing,timing +timeot,timeout +timeput,timeout +timeputs,timeouts +timere,timer +timespanp,timespan +timespanps,timespans +timestan,timespan +timestanp,timestamp,timespan +timestanps,timestamps,timespans +timestans,timespans timestap,timestamp +timestemp,timestamp +timestemps,timestamps timestmap,timestamp +timestmaps,timestamps +timetamp,timestamp +timetamps,timestamps +timmestamp,timestamp +timmestamps,timestamps +timming,timing,trimming timne,time +timoeut,timeout +timout,timeout +timtout,timeout +timzeone,timezone +timzeones,timezones +timzezone,timezone +timzezones,timezones tindergarten,kindergarten +tinterrupts,interrupts tiolets,toilets -tiome,time +tiome,time,tome +tipe,type,tip +tipically,typically tirangle,triangle tirangles,triangles tirbunal,tribunal @@ -25816,6 +48158,11 @@ tirdent,trident titainum,titanium titanim,titanium titanuim,titanium +titel,title +titels,titles +titile,title +tittled,titled +tittling,titling tje,the tjhe,the tjpanishad,upanishad @@ -25823,30 +48170,66 @@ tkae,take tkaes,takes tkaing,taking tlaking,talking +tmis,this +toally,totally tobbaco,tobacco +tobot,robot +toches,touches +tocksen,toxin tocuhdown,touchdown tocuhpad,touchpad tocuhscreen,touchscreen todya,today +toekn,token togehter,together +toggel,toggle togheter,together toghether,together +togling,toggling +toglle,toggle +toglled,toggled +togther,together +toi,to,toy toiletts,toilets +tolarable,tolerable +tolelerance,tolerance +tolen,token +tolens,tokens tolerabe,tolerable +toleranz,tolerance tolerence,tolerance +tolernce,tolerance toliets,toilets tolkein,tolkien +tollerable,tolerable +tollerance,tolerance +tollerances,tolerances +tomatoe,tomato tomatos,tomatoes tommorow,tomorrow tommorrow,tomorrow +tomorrrow,tomorrow tongiht,tonight tonguers,tongues +tonihgt,tonight tonuges,tongues tood,todo +toogle,toggle +toogling,toggling +tookit,toolkit +tookits,toolkits +toolar,toolbar +toolsbox,toolbox +toom,tomb +tooo,todo +toos,tools toothbruch,toothbrush toothbruth,toothbrush toothbursh,toothbrush toothrbush,toothbrush +tootonic,teutonic +topicaizer,topicalizer +topologie,topology toppingest,toppings toppins,toppings torando,tornado @@ -25856,10 +48239,12 @@ torchlgiht,torchlight torchligt,torchlight torchligth,torchlight torelable,tolerable +torerable,tolerable torhclight,torchlight toriodal,toroidal toritlla,tortilla toritllas,tortillas +tork,torque tornadoe,tornado tornaodes,tornadoes torndao,tornado @@ -25867,6 +48252,7 @@ torotise,tortoise torpdeo,torpedo torpeados,torpedoes torpedeo,torpedo +torpedos,torpedoes torphies,trophies torrentas,torrents torrentbig,torrenting @@ -25878,6 +48264,7 @@ torrentting,torrenting torrest,torrents tortialls,tortillas tortila,tortilla +tortilini,tortellini tortillera,tortilla tortillia,tortilla tortillias,tortilla @@ -25885,6 +48272,7 @@ tortillita,tortilla tortillla,tortilla tortilllas,tortilla tortiose,tortoise +tortise,tortoise torubleshoot,troubleshoot torublesome,troublesome toruisty,touristy @@ -25892,28 +48280,42 @@ torunament,tournament torunaments,tournaments toruney,tourney toruneys,tourneys +torward,toward +torwards,towards totalitara,totalitarian totalitaran,totalitarian totalitarion,totalitarian totalitarni,totalitarian totalitatian,totalitarian +totation,rotation +tothiba,toshiba +totol,total +totorial,tutorial +totorials,tutorials tottehnam,tottenham tottenahm,tottenham tottneham,tottenham toturials,tutorials +touble,trouble toubles,troubles +toubling,troubling touchapd,touchpad touchda,touchpad touchdwon,touchdown touchsceen,touchscreen touchscreeen,touchscreen touchscren,touchscreen +tought,thought,taught,tough +toughtful,thoughtful +toughtly,tightly +toughts,thoughts tounge,tongue tounrey,tourney tounreys,tourneys +touple,tuple touranment,tournaments touranments,tournaments -tourch,torch +tourch,torch,touch tourisim,tourism touristas,tourists touristes,tourists @@ -25941,32 +48343,62 @@ toursits,tourists toursity,touristy towords,towards towrad,toward +toxen,toxin toxicitity,toxicity toxicitiy,toxicity toxiticy,toxicity +tpyo,typo trabajao,trabajo trabajdo,trabajo +trabsform,transform +traceablity,traceability trackes,trackers +trackign,tracking +trackling,tracking trackres,trackers +tracsode,transcode +tracsoded,transcoded +tracsoder,transcoder +tracsoders,transcoders +tracsodes,transcodes +tracsoding,transcoding +tradgic,tragic tradicional,traditional tradionally,traditionally tradisional,traditional +traditilnal,traditional +traditiona,traditional traditionaly,traditionally traditionel,traditional traditionnal,traditional +traditionnally,traditionally traditition,tradition +tradtional,traditional tradtionally,traditionally trafficed,trafficked trafficing,trafficking trafic,traffic +tragectory,trajectory +traget,target trageted,targeted +trageting,targeting +tragets,targets tragicallly,tragically tragicaly,tragically +traiing,trailing,training traileras,trailers trailes,trailers +trailling,trailing traines,trainers traingle,triangle traingles,triangles +traingular,triangular +traingulate,triangulate +traingulated,triangulated +traingulates,triangulates +traingulating,triangulating +traingulation,triangulation +traingulations,triangulations trainig,training trainwreak,trainwreck trainwrek,trainwreck @@ -25974,8 +48406,12 @@ traitoris,traitors traitorus,traitors traitour,traitor trakcers,trackers +traker,tracker +traking,tracking tralier,trailer traliers,trailers +traling,trailing,trialing +trama,trauma tramautic,traumatic tramautized,traumatized tramboline,trampoline @@ -25984,32 +48420,74 @@ tramploine,trampoline trampolene,trampoline tramsformers,transformers tramsforming,transforming +tramsmit,transmit +tramsmitted,transmitted tramuatized,traumatized +tranaction,transaction +tranactional,transactional +tranactions,transactions +tranasction,transaction +tranceiver,transceiver +tranceivers,transceivers trancendent,transcendent trancending,transcending +tranclate,translate tranclucent,translucent trandgender,transgender tranditional,transitional tranditions,transitions +tranfer,transfer +tranfered,transferred +tranfering,transferring +tranferred,transferred +tranfers,transfers tranform,transform +tranformable,transformable +tranformation,transformation +tranformations,transformations +tranformative,transformative tranformed,transformed +tranforming,transforming +tranforms,transforms +tranient,transient tranistion,transition tranistional,transitional tranistioned,transitioned tranistioning,transitioning tranistions,transitions tranlastion,translations +tranlatable,translatable +tranlate,translate +tranlated,translated +tranlates,translates +tranlating,translating +tranlation,translation +tranlations,translations tranlsate,translate tranlsated,translated tranlsating,translating tranlsation,translation tranlsations,translations tranluscent,translucent +tranmission,transmission +tranmist,transmit +tranmitted,transmitted +tranmitting,transmitting tranmsission,transmissions trannsexual,transsexual +tranparent,transparent +tranparently,transparently +tranport,transport tranpshobic,transphobic transaccion,transaction +transacion,transaction transaciton,transactions +transactoin,transaction +transaition,translation,transition,transaction +transaitions,translations,transitions,transactions +transalation,translation +transalations,translations +transalt,translate transalte,translate transalted,translated transaltes,translates @@ -26017,20 +48495,48 @@ transalting,translating transaltion,translation transaltions,translations transaltor,translator +transaltors,translators transaprency,transparency -transation,transition +transation,transition,transaction,translation transational,transitional -transations,transitions +transations,transitions,transactions,translations transcations,transactions transcendance,transcendence transcendant,transcendent transcendentational,transcendental +transcevier,transceiver +transciever,transceiver +transcievers,transceivers transciprt,transcripts transcirpt,transcripts transcluent,translucent +transcocde,transcode +transcocded,transcoded +transcocder,transcoder +transcocders,transcoders +transcocdes,transcodes +transcocding,transcoding +transcocdings,transcodings +transconde,transcode +transconded,transcoded +transconder,transcoder +transconders,transcoders +transcondes,transcodes +transconding,transcoding +transcondings,transcodings +transcorde,transcode +transcorded,transcoded +transcorder,transcoder +transcorders,transcoders +transcordes,transcodes +transcording,transcoding +transcordings,transcodings +transcoser,transcoder +transcosers,transcoders transcribtion,transcription transcripcion,transcription transcrips,transcripts +transcripting,transcribing,transcription transcripto,transcription transcripton,transcription transcriptus,transcripts @@ -26042,7 +48548,9 @@ transcrpit,transcript transctions,transitions transculent,translucent transeat,translates +transeint,transient transending,transcending +transer,transfer transesxuals,transsexuals transfarmers,transformers transfarring,transferring @@ -26054,14 +48562,23 @@ transferer,transferred transferers,transfers transferes,transfers transfering,transferring +transferrd,transferred transferrred,transferred transferrring,transferring transferrs,transfers transfersom,transforms +transfert,transfer,transferred transferts,transfers transfom,transform +transfomation,transformation +transfomational,transformational transfomed,transformed +transfomer,transformer transfomers,transforms +transfomm,transform +transfoprmation,transformation +transforation,transformation +transforations,transformations transfored,transformed transformacion,transformation transformare,transformers @@ -26070,8 +48587,11 @@ transformarem,transformer transformarse,transformers transformas,transforms transformase,transforms +transformated,transformed +transformates,transforms transformaton,transformation -transforme,transfer +transformatted,transformed +transforme,transfer,transformed,transformer,transform transformees,transforms transformered,transformed transformes,transformers @@ -26082,9 +48602,11 @@ transfors,transforms transforums,transforms transfos,transforms transfrom,transform +transfromate,transform,transformed transfromation,transformation +transfromations,transformations transfromed,transformed -transfromer,transformers +transfromer,transformers,transformer transfromers,transformers transfroming,transforming transfroms,transforms @@ -26108,9 +48630,11 @@ transision,transition transisioned,transitioned transisioning,transitioning transisions,transitions +transisition,transition transisitor,transistor transister,transistor transistion,transition +transistions,transitions transistior,transistor transiten,transient transitin,transitions @@ -26122,18 +48646,25 @@ transitionnal,transitional transitionned,transitioned transitionning,transitioning transito,transition +transiton,transition transitons,transitions -transitors,transistor +transitor,transistor +transitors,transistor,transistors transkript,transcript transkription,transcription translastion,translations translateing,translating translater,translator +translaters,translators +translatied,translated translatin,translations translatio,translator translationg,translating +translatoin,translation +translatoins,translations translatron,translation translpant,transplants +translteration,transliteration translucient,translucent transluent,translucent translusent,translucent @@ -26144,40 +48675,112 @@ transmision,transmission transmisions,transmission transmisison,transmission transmisisons,transmissions +transmisive,transmissive transmissable,transmissible transmissin,transmissions +transmissione,transmission transmisson,transmission transmissons,transmissions transmisssion,transmissions +transmist,transmit transmited,transmitted transmiter,transmitter +transmiters,transmitters +transmiting,transmitting +transmition,transmission transmitirte,transmitter transmitor,transistor +transmitsion,transmission +transmittd,transmitted +transmittion,transmission transmittor,transmitter +transmitts,transmits transmittted,transmitted +transmmit,transmit transmorfers,transformer transmorged,transformed transmorgs,transforms transmutter,transmitter +transocde,transcode +transocded,transcoded +transocder,transcoder +transocders,transcoders +transocdes,transcodes +transocding,transcoding +transocdings,transcodings transofrm,transform transofrmation,transformation transofrmed,transformed transofrmers,transformers transofrming,transforming transohobic,transphobic +transolate,translate +transolated,translated +transolates,translates +transolating,translating +transolation,translation +transolations,translations +transorm,transform +transormed,transformed +transorming,transforming +transorms,transforms +transpable,transposable +transpacencies,transparencies +transpacency,transparency +transpaernt,transparent +transpaerntly,transparently transpalnt,transplants +transpancies,transparencies +transpancy,transparency +transpant,transplant +transparaent,transparent +transparaently,transparently +transparanceies,transparencies +transparancey,transparency +transparancies,transparencies transparancy,transparency +transparanet,transparent +transparanetly,transparently +transparanies,transparencies transparant,transparent transparantie,transparent +transparantly,transparently +transparany,transparency +transpararent,transparent +transpararently,transparently +transparcencies,transparencies +transparcency,transparency +transparcenies,transparencies +transparceny,transparency transparecy,transparency transparentcy,transparency transparenty,transparency transpareny,transparency +transparities,transparencies +transparity,transparency +transparnecies,transparencies +transparnecy,transparency +transparnt,transparent +transparntly,transparently +transparren,transparent +transparrenly,transparently transparrent,transparent +transparrently,transparently +transpart,transport +transparts,transports +transpatrent,transparent +transpatrently,transparently +transpencies,transparencies +transpency,transparency +transpeorted,transported +transperancies,transparencies transperancy,transparency transperant,transparent +transperantly,transparently +transperencies,transparencies transperency,transparency transperent,transparent +transperently,transparently transphoic,transphobic transphonic,transphobic transphopic,transphobic @@ -26197,6 +48800,7 @@ transportar,transporter transportarme,transporter transportarse,transporter transportarte,transporter +transportatin,transportation transporteur,transporter transporteurs,transporter transportion,transporting @@ -26205,6 +48809,20 @@ transportor,transporter transportr,transporter transpot,transport transpotting,transporting +transprencies,transparencies +transprency,transparency +transprent,transparent +transprently,transparently +transprot,transport +transproted,transported +transproting,transporting +transprots,transports +transprt,transport +transprted,transported +transprting,transporting +transprts,transports +transpsition,transposition +transsend,transcend transseuxal,transsexual transsexal,transsexual transsexaul,transsexual @@ -26212,15 +48830,59 @@ transsexuel,transsexual transsexuella,transsexual transsmision,transmissions transtator,translator +transtion,transition +transtions,transitions +transtition,transition +transtitions,transitions +transtorm,transform +transtormed,transformed transulcent,translucent +transvorm,transform +transvormation,transformation +transvormed,transformed +transvorming,transforming +transvorms,transforms transylmania,transylvania transylvanai,transylvania transylvannia,transylvania transylvnia,transylvania +tranversing,traversing tranzformer,transformer tranzistor,transistor tranzitions,transitions tranzporter,transporter +trapeziod,trapezoid +trapeziodal,trapezoidal +trasaction,transaction +trascation,transaction +trasfer,transfer +trasferred,transferred +trasfers,transfers +trasform,transform +trasformable,transformable +trasformation,transformation +trasformations,transformations +trasformative,transformative +trasformed,transformed +trasformer,transformer +trasformers,transformers +trasforming,transforming +trasforms,transforms +traslalate,translate +traslalated,translated +traslalating,translating +traslalation,translation +traslalations,translations +traslate,translate +traslated,translated +traslates,translates +traslating,translating +traslation,translation +traslations,translations +traslucency,translucency +trasmission,transmission +trasmit,transmit +trasnaction,transaction trasncript,transcript trasncripts,transcripts trasnfer,transfer @@ -26236,7 +48898,10 @@ trasnforming,transforming trasnforms,transforms trasngender,transgender trasngendered,transgendered +trasnlate,translate trasnlated,translated +trasnlation,translation +trasnlations,translations trasnlator,translator trasnmission,transmissions trasnmitted,transmitted @@ -26250,31 +48915,77 @@ trasnportation,transportation trasnported,transported trasnporter,transporter trasnporting,transporting +trasnports,transports +trasnsmit,transmit +trasparency,transparency +trasparent,transparent +trasparently,transparently +trasport,transport +trasportable,transportable +trasported,transported +trasporter,transporter +trasports,transports +traspose,transpose +trasposed,transposed +trasposition,transposition +traspositions,transpositions tratior,traitor tratiors,traitors traumatisch,traumatic traumetized,traumatized traumitized,traumatized +traved,traversed +traveersal,traversal +traveerse,traverse +traveersed,traversed +traveerses,traverses +traveersing,traversing traveld,traveled traveleres,travelers traveles,travels travellerhd,travelled travellodge,travelled travelodge,traveled +traveral,traversal +travercal,traversal +traverce,traverse +traverced,traversed +traverces,traverses +travercing,traversing travere,traverse +travered,traversed traveres,traverse +traveresal,traversal +traverese,traverse,traverses +traveresed,traversed +travereses,traverses +traveresing,traversing +travering,traversing traverlers,traverse +traverls,travels,traversals traversare,traverse traversie,traverse traversier,traverse +travesal,traversal +travese,traverse +travesed,traversed +traveses,traverses +travesing,traversing travestry,travesty travesy,travesty travles,travels +tre,tree +treadet,treated +treak,treat,tweak treasue,treasure treasuers,treasures treasurery,treasury treasurey,treasury treasurs,treasures +treate,treat +treatement,treatment +treatements,treatments +treates,treats treatis,treaties treatmens,treatments treatmet,treatments @@ -26293,20 +49004,33 @@ tremendoulsy,tremendously tremenduous,tremendous tremondous,tremendous tremondously,tremendously +trempoline,trampoline trendig,trending +treshhold,threshold +treshold,threshold trespasing,trespassing trespessing,trespassing +tressle,trestle tresspasing,trespassing tresuary,treasury +treting,treating +trgistration,registration +trhe,the trhilling,thrilling trhusters,thrusters trialer,trailer trialers,trailers +triancle,triangle +triancles,triangles trianers,trainers triange,triangle triangel,triangle triangels,triangles triangls,triangles +trianglular,triangular +trianglutaion,triangulation +triangulataion,triangulation +triangultaion,triangulation trianing,training trianlge,triangle trianlges,triangles @@ -26318,23 +49042,54 @@ tribunaal,tribunal trickey,trickery trickyer,trickery tridnet,trident +triger,trigger,tiger +trigered,triggered +trigerred,triggered +trigerring,triggering +trigers,triggers +trigged,triggered +triggerd,triggered triggereing,triggering +triggeres,triggers triggern,triggering +triggerred,triggered triggerring,triggering +triggger,trigger triguered,triggered +trik,trick,trike +triked,tricked +trikery,trickery +triks,tricks,trikes +triky,tricky trilogoy,trilogy +trimed,trimmed +triming,trimming,timing trimuph,triumph trinagle,triangle trinagles,triangles trinekts,trinkets +tring,trying,string,ring tringale,triangle +trings,strings,rings trinitiy,trinity +triniy,trinity trinkes,trinkets trinkst,trinkets trintiy,trinity triolgy,trilogy triology,trilogy +tripple,triple triumpth,triumph +trival,trivial +trivally,trivially +trivias,trivia +trnasfers,transfers +trnasmit,transmit +trnasmited,transmitted +trnasmits,transmits +trnsfer,transfer +trnsfered,transferred +trnsfers,transfers trochlight,torchlight trohpies,trophies troleld,trolled @@ -26344,6 +49099,7 @@ tronado,tornado tropcial,tropical tropedo,torpedo trotilla,tortilla +trottle,throttle troubelshoot,troubleshoot troubelshooting,troubleshooting troubelsome,troublesome @@ -26351,19 +49107,49 @@ troublehsoot,troubleshoot troublehsooting,troubleshooting troubleshooot,troubleshoot troubleshotting,troubleshooting -troups,troupes +troublshooting,troubleshooting +troughput,throughput +trought,through +troup,troupe +troups,troupes,troops trpoical,tropical truamatic,traumatic truamatized,traumatized +trubble,trouble +trubbled,troubled +trubbles,troubles trubinal,tribunal trubines,turbines +truble,trouble +trubled,troubled +trubles,troubles +trucate,truncate +trucated,truncated +trucates,truncates +trucating,truncating +trucnate,truncate +trucnated,truncated +trucnating,truncating trudnle,trundle +truelly,truly truely,truly +truied,tried truimph,triumph trukish,turkish +trully,truly trumendously,tremendously +trun,turn +trunacted,truncated +truncat,truncate +trunctate,truncate +trunctated,truncated +trunctating,truncating +trunctation,truncation +truncted,truncated trundel,trundle +truned,turned trunlde,trundle +truns,turns trushworthy,trustworthy trustowrthy,trustworthy trustwhorty,trustworthy @@ -26372,85 +49158,172 @@ trustworhy,trustworthy trustworthly,trustworthy trustworthyness,trustworthiness trustworty,trustworthy +trustwortyness,trustworthiness trustwothy,trustworthy truthfullly,truthfully truthfuly,truthfully +truw,true tryahrd,tryhard tryannical,tyrannical tryavon,trayvon +tryed,tried +tryes,tries +tryig,trying +tryinng,trying +trys,tries tsamina,stamina tsnuami,tsunami tsuanmi,tsunami tsunamai,tsunami tsunmai,tsunami +ttests,tests +tthe,the tuesdsay,tuesdays tuesdsy,tuesdays +tufure,future +tuhmbnail,thumbnail +tunelled,tunnelled +tunelling,tunnelling +tunned,tuned +tunnell,tunnel tunnells,tunnels +tunning,tuning,running tunnles,tunnels tunraround,turnaround tunrtable,turntable +tuotiral,tutorial +tuotirals,tutorials +tupel,tuple tupparware,tupperware tupperwears,tupperware +tupple,tuple +tupples,tuples turbins,turbines +ture,true turkisch,turkish turksih,turkish +turle,turtle turltes,turtles +turly,truly turnapound,turnaround turnaroud,turnaround +turnk,trunk,turnkey,turn turntabe,turntable turntabel,turntable +turorial,tutorial +turorials,tutorials turrest,turrets turretts,turrets turstworthy,trustworthy turtels,turtles turthfully,truthfully +turtorial,tutorial +turtorials,tutorials +tuscon,tucson tuseday,tuesday tusedays,tuesdays tusnami,tsunami tust,trust +tution,tuition tutoriales,tutorials +tutoriel,tutorial +tutoriels,tutorials tutorual,tutorial tutrles,turtles +tweleve,twelve twelth,twelfth twilgiht,twilight twiligt,twilight twon,town +twoo,two,too twpo,two +tye,type,tie tyelnol,tylenol +tyep,type +tyes,types,ties tyhat,that tyhe,they +tyies,tries tylenool,tylenol +tymecode,timecode +tyope,type +typcast,typecast +typcasting,typecasting +typcasts,typecasts typcial,typical typcially,typically +typechek,typecheck +typecheking,typechecking +typicall,typically,typical +typicallly,typically typicaly,typically +typicially,typically +typle,tuple +typles,tuples +typoe,typo,type,types +typoes,typos,types +typographc,typographic +typpe,type +typped,typed +typpes,types tyranies,tyrannies tyrannia,tyrannical tyrantical,tyrannical tyrany,tyranny tyrhard,tryhard +tyring,trying tyrranies,tyrannies tyrrany,tyranny +ubelieveble,unbelievable +ubelievebly,unbelievably +ubernetes,kubernetes ubiqituous,ubiquitous ubiquitious,ubiquitous ubiquitos,ubiquitous ubiquituous,ubiquitous +ubiquituously,ubiquitously ubiquotous,ubiquitous ubiqutious,ubiquitous +ubitquitous,ubiquitous ublisher,publisher ubsubscribed,unsubscribed ubsubstantiated,unsubstantiated +ubunut,ubuntu +ubutunu,ubuntu +udated,updated,dated +udater,updater,dater +udating,updating,dating udnercut,undercut udnerdog,underdog udnerestimate,underestimated udnerpowered,underpowered +udno,undo,uno +udpatable,updatable +udpate,update udpated,updated +udpater,updater +udpates,updates +udpating,updating +ue,use,due +ueful,useful +uegister,unregister +uesd,used uesfull,usefull +uggly,ugly +ugglyness,ugliness +uglyness,ugliness ugprade,upgrade ugpraded,upgraded ugprades,upgrades ugprading,upgrading +uique,unique uise,use +uite,suite +uites,suites ukarine,ukraine +uknown,unknown +uknowns,unknowns +ukowns,unknowns,unknown ukrainain,ukrainian ukrainains,ukrainians ukraineans,ukrainians @@ -26467,38 +49340,64 @@ ukranie,ukraine ukriane,ukraine ukrianian,ukrainian ukrianians,ukrainians +ulimited,unlimited ulitmate,ultimate ulitmately,ultimately ulitmatum,ultimatum ultamite,ultimate +ulter,alter +ulteration,alteration +ulterations,alterations +ultered,altered +ultering,altering ulterioara,ulterior ulterioare,ulterior ulteriour,ulterior +ulters,alters ultiamte,ultimate ultimae,ultimate ultimatelly,ultimately ultimative,ultimate ultimatley,ultimately +ultimatly,ultimately ultimatuum,ultimatum ultimely,ultimately ultrason,ultrasound +umambiguous,unambiguous +umark,unmark +umarked,unmarked umbelievable,unbelievable umberlla,umbrella +umbrealla,umbrella umbrela,umbrella umbrellla,umbrella umcomfortable,uncomfortable umcomfortably,uncomfortably umemployment,unemployment +uminportant,unimportant +umit,unit +ummark,unmark +umoutn,umount umpredictable,unpredictable +unabailable,unavailable +unabale,unable unabel,unable unabnned,unbanned unaccaptable,unacceptable unacceptible,unacceptable +unaccesible,unaccessible unaccpetable,unacceptable +unacknowleged,unacknowledged unacompanied,unaccompanied unahppy,unhappy +unalllowed,unallowed +unambigious,unambiguous +unambigous,unambiguous +unambigously,unambiguously +unamed,unnamed unaminous,unanimous unanimoulsy,unanimous +unanimuous,unanimous unanmious,unanimous unanswerd,unanswered unanwsered,unanswered @@ -26508,21 +49407,37 @@ unappeasing,unappealing unappeeling,unappealing unappropriate,inappropriate unappropriately,inappropriately +unaquired,unacquired +unarchving,unarchiving unasnwered,unanswered +unathenticated,unauthenticated unathorised,unauthorised unattanded,unattended +unatteded,unattended unattendend,unattended unatteneded,unattended unattented,unattended unattracive,unattractive unattractice,unattractive +unauthenicated,unauthenticated unautherized,unauthorized unauthoried,unauthorized unauthroized,unauthorized +unavaiable,unavailable +unavaialable,unavailable +unavaialbale,unavailable +unavaialbe,unavailable +unavaialbel,unavailable +unavaialbility,unavailability +unavaialble,unavailable +unavaible,unavailable unavailabe,unavailable +unavailabel,unavailable unavailble,unavailable unavailible,unavailable unavaliable,unavailable +unavaoidable,unavoidable +unavilable,unavailable unaviodable,unavoidable unavoidble,unavoidable unawnsered,unanswered @@ -26541,20 +49456,35 @@ unbeateble,unbeatable unbeerable,unbearable unbeetable,unbeatable unbeknowst,unbeknownst +unbeleifable,unbelievable unbeleivable,unbelievable unbeleivably,unbelievably unbeliavable,unbelievable unbeliavably,unbelievably unbeliebable,unbelievable +unbeliefable,unbelievable unbelievablely,unbelievably unbelievabley,unbelievably unbelievablly,unbelievably unbelieveble,unbelievable unbelievibly,unbelievably +unbelivable,unbelievable unbeliveable,unbelievable unbeliveably,unbelievably +unbelivebly,unbelievably unbelizeable,unbelievable unbolievable,unbelievable +unborned,unborn +unbouind,unbound +unbouinded,unbounded +unboun,unbound +unbounad,unbound +unbounaded,unbounded +unbouned,unbounded +unbounnd,unbound +unbounnded,unbounded +unbouund,unbound +unbouunded,unbounded unbraikable,unbreakable unbrakeable,unbreakable unbreakabie,unbreakable @@ -26563,15 +49493,22 @@ unbreakbale,unbreakable unbreakble,unbreakable unbreakeble,unbreakable unbrearable,unbreakable +unbunded,unbundled,unbounded +uncahnged,unchanged +uncalcualted,uncalculated uncanney,uncanny uncannny,uncanny uncatalogued,uncataloged +unce,once +uncehck,uncheck +uncehcked,unchecked uncencored,uncensored uncensered,uncensored uncensord,uncensored uncensorred,uncensored uncersored,uncensored uncertaincy,uncertainty +uncertainities,uncertainties uncertainity,uncertainty uncertaintity,uncertainty uncertaintly,uncertainty @@ -26580,8 +49517,22 @@ uncertanity,uncertainty uncertanty,uncertainty uncertianty,uncertainty uncesnored,uncensored +uncessarily,unnecessarily +unchache,uncache +unchached,uncached +unchaged,unchanged +unchainged,unchanged unchallengable,unchallengeable +unchaned,unchanged +unchaneged,unchanged unchangable,unchangeable +uncheked,unchecked +unchenged,unchanged +uncognized,unrecognized +uncoment,uncomment +uncomented,uncommented +uncomenting,uncommenting +uncoments,uncomments uncomfertable,uncomfortable uncomfertably,uncomfortably uncomfortabel,uncomfortably @@ -26597,17 +49548,53 @@ uncomftorably,uncomfortably uncomited,uncommitted uncomitted,uncommitted uncommited,uncommitted +uncommment,uncomment +uncommmented,uncommented +uncommmenting,uncommenting +uncommments,uncomments +uncommmitted,uncommitted +uncommmon,uncommon +uncommpresed,uncompressed +uncommpresion,uncompression +uncommpressd,uncompressed +uncommpressed,uncompressed +uncommpression,uncompression +uncommtited,uncommitted +uncomon,uncommon uncompatible,incompatible +uncompetetive,uncompetitive uncompetive,uncompetitive +uncomplete,incomplete +uncompleteness,incompleteness +uncompletness,incompleteness +uncompres,uncompress +uncompresed,uncompressed +uncompreses,uncompresses +uncompresing,uncompressing +uncompresor,uncompressor +uncompresors,uncompressors +uncomprss,uncompress unconcious,unconscious unconciousness,unconsciousness +unconcistencies,inconsistencies +unconcistency,inconsistency +unconcistent,inconsistent unconcsious,unconscious unconcsiously,unconsciously +uncondisional,unconditional +uncondisionaly,unconditionally +uncondisionnal,unconditional +uncondisionnaly,unconditionally unconditinal,unconditional +unconditinally,unconditionally unconditionable,unconditional unconditionaly,unconditionally unconditionnal,unconditional unconditionnally,unconditionally +unconditionnaly,unconditionally +uncondtional,unconditional +uncondtionally,unconditionally +unconfiged,unconfigured unconfortability,discomfort unconfortable,uncomfortable unconfortably,uncomfortably @@ -26619,6 +49606,7 @@ unconscous,unconscious unconsicous,unconscious unconsicously,unconsciously unconsiderate,inconsiderate +unconsisntency,inconsistency unconsistent,inconsistent unconstititional,unconstitutional unconstituional,unconstitutional @@ -26626,6 +49614,7 @@ unconstitutionnal,unconstitutional uncontitutional,unconstitutional uncontrallable,uncontrollable uncontrallably,uncontrollably +uncontrolable,uncontrollable uncontrolablly,uncontrollably uncontrollabe,uncontrollable uncontrollablely,uncontrollably @@ -26640,12 +49629,26 @@ unconvential,unconventional unconventianal,unconventional unconventinal,unconventional unconventionnal,unconventional +uncorectly,incorrectly +uncorelated,uncorrelated +uncorrect,incorrect +uncorrectly,incorrectly +uncorrolated,uncorrelated uncouncious,unconscious uncounciously,unconsciously uncousciously,unconsciously +uncoverted,unconverted +uncrypted,unencrypted undebiably,undeniably undecideable,undecidable +undefied,undefined +undefien,undefine +undefiend,undefined +undefinied,undefined undefinitely,indefinitely +undeflow,underflow +undeflows,underflows +undefuned,undefined undeinable,undeniable undeinably,undeniably undenaible,undeniable @@ -26657,6 +49660,7 @@ undeniablly,undeniably undenialbly,undeniably undenyable,undeniable undenyably,undeniably +undependend,independent,nondependent underastimate,underestimate underastimated,underestimated underastimating,underestimating @@ -26676,6 +49680,8 @@ underestimateing,underestimating underestime,underestimate underestimeted,underestimated underfaker,undertaker +underfiend,undefined +underfined,undefined undergard,undergrad undergated,underrated undergating,undertaking @@ -26690,6 +49696,9 @@ undergrund,underground underheight,underweight underhwelming,underwhelming underhwleming,underwhelming +underlayed,underlaid +underlaying,underlying +underlow,underflow undermimes,undermines undermiming,undermining underminde,undermines @@ -26718,12 +49727,17 @@ underraged,underrated underraker,undertaker underrater,undertaker underratted,underrated +underrrun,underrun +undersacn,underscan undersatnd,understands undersetimate,underestimate undersetimated,underestimated undersog,undergo understad,understands -understadn,understands +understadn,understands,understand +understadnable,understandable +understadning,understanding +understadns,understands understandablely,understandably understandabley,understandably understandble,understandable @@ -26735,14 +49749,28 @@ understannd,understands understans,understands understnad,understands understoon,understood +understoud,understood understsand,understands understsnd,understands +undertable,understandable,understand undertacker,undertaker undertakeing,undertaking +undertand,understand +undertandable,understandable +undertanded,understood +undertanding,understanding +undertands,understands undertoe,undertones undertoker,undertaker -undertsand,understands +undertsand,understands,understand +undertsanding,understanding +undertsands,understands +undertsood,understood +undertstand,understand +undertstands,understands undertunes,undertones +underun,underrun +underuns,underruns underwaer,underwear underwager,underwater underwar,underwater @@ -26765,10 +49793,23 @@ undesireable,undesirable undesireble,undesirable undesriable,undesirable undesrtand,understands +undestand,understand +undestood,understood undestructible,indestructible +undet,under undetecable,undetectable +undetstand,understand +undetware,underwear +undetwater,underwater +undfine,undefine +undfined,undefined +undfines,undefines undiserable,undesirable +undistinghable,indistinguishable undoctrinated,indoctrinated +undoed,undo,undone +undorder,unorder +undordered,unordered undoubedtly,undoubtedly undoubetdly,undoubtedly undoubtadly,undoubtedly @@ -26779,10 +49820,16 @@ undoubtely,undoubtedly undoubtetly,undoubtedly undoubtley,undoubtedly undreground,underground +undupplicated,unduplicated uneccesary,unnecessary +uneccessarily,unnecessarily +unecessarily,unnecessarily unecessary,unnecessary unedcuated,uneducated unedicated,uneducated +uneeded,unneeded,unheeded,needed +uneforceable,unenforceable +uneform,uniform unemployeed,unemployed unemployemnt,unemployment unemployent,unemployment @@ -26790,69 +49837,165 @@ unemploymed,unemployed unemplyoment,unemployment unempolyed,unemployed unempolyment,unemployment +unencrpt,unencrypt +unencrpted,unencrypted +unenforcable,unenforceable unenployment,unemployment +unepected,unexpected +unepectedly,unexpectedly unequalities,inequalities +unequality,inequality +uner,under +unesacpe,unescape +unesacped,unescaped +unessecarry,unnecessary +unessecary,unnecessary +unexcected,unexpected +unexcectedly,unexpectedly +unexcpected,unexpected +unexcpectedly,unexpectedly +unexecpted,unexpected +unexecptedly,unexpectedly +unexected,unexpected +unexectedly,unexpectedly +unexepcted,unexpected +unexepctedly,unexpectedly +unexepected,unexpected +unexepectedly,unexpectedly +unexpacted,unexpected +unexpactedly,unexpectedly +unexpcted,unexpected +unexpctedly,unexpectedly +unexpecetd,unexpected +unexpecetdly,unexpectedly +unexpect,unexpected unexpectadely,unexpectedly unexpectadly,unexpectedly +unexpectd,unexpected unexpectdly,unexpectedly +unexpecte,unexpected unexpectely,unexpectedly +unexpectend,unexpected +unexpectendly,unexpectedly unexpectetly,unexpectedly unexpectidly,unexpectedly +unexpectly,unexpectedly +unexpeected,unexpected +unexpeectedly,unexpectedly +unexpepected,unexpected +unexpepectedly,unexpectedly +unexpepted,unexpected +unexpeptedly,unexpectedly +unexpercted,unexpected +unexperctedly,unexpectedly unexperience,inexperience +unexpested,unexpected +unexpestedly,unexpectedly +unexpetced,unexpected +unexpetcedly,unexpectedly +unexpetct,unexpected +unexpetcted,unexpected +unexpetctedly,unexpectedly +unexpetctly,unexpectedly +unexpetect,unexpected +unexpetected,unexpected +unexpetectedly,unexpectedly +unexpetectly,unexpectedly +unexpeted,unexpected +unexpetedly,unexpectedly +unexpexcted,unexpected +unexpexctedly,unexpectedly +unexpexted,unexpected unexpextedly,unexpectedly unexplaind,unexplained unexplaned,unexplained unexplicably,inexplicably +unexspected,unexpected +unexspectedly,unexpectedly unfailry,unfairly unfairy,unfairly unfamilair,unfamiliar unfamilier,unfamiliar unfamilliar,unfamiliar unfarily,unfairly +unfilp,unflip +unfilpped,unflipped +unfilpping,unflipping +unfilps,unflips unfinsihed,unfinished unfirendly,unfriendly +unflaged,unflagged +unflexible,inflexible unfomfortable,uncomfortable unforetunately,unfortunately unforgetable,unforgettable unforgiveable,unforgivable unforgiveble,unforgivable unforgivible,unforgivable +unformated,unformatted unforseen,unforeseen +unforttunately,unfortunately unfortuante,unfortunate unfortuantely,unfortunately unfortuate,unfortunate +unfortunaltely,unfortunately +unfortunaly,unfortunately unfortunantly,unfortunately +unfortunat,unfortunate unfortunatelly,unfortunately +unfortunatetly,unfortunately unfortunatley,unfortunately unfortunatly,unfortunately unfortune,unfortunate unfortuneatly,unfortunately unfortunetely,unfortunately unfortunetly,unfortunately +unfortuntaly,unfortunately +unforunate,unfortunate +unforunately,unfortunately +unforutunate,unfortunate +unforutunately,unfortunately unfourtunately,unfortunately +unfourtunetly,unfortunately unfreindly,unfriendly unfriednly,unfriendly unfriendy,unfriendly unfriently,unfriendly +unfurtunately,unfortunately +ungeneralizeable,ungeneralizable ungodley,ungodly ungoldy,ungodly ungrapeful,ungrateful ungreatful,ungrateful ungreatfull,ungrateful +unhandeled,unhandled unhapppy,unhappy unhealhty,unhealthy unhealthly,unhealthy unhealty,unhealthy unheathly,unhealthy unhelathy,unhealthy +unhilight,unhighlight +unhilighted,unhighlighted +unhilights,unhighlights +unicde,unicode unicornios,unicorns unicornis,unicorns unicornus,unicorns unicors,unicorns unicrons,unicorns +unidentifiedly,unidentified +unidimensionnal,unidimensional +unifiy,unify unifnished,unfinished +uniformely,uniformly uniformes,uniforms +uniformy,uniformly,uniform +unifrom,uniform +unifromed,uniformed +unifromity,uniformity unifroms,uniforms +unigned,unsigned unihabited,uninhabited unilaterallly,unilaterally unilateraly,unilaterally @@ -26860,96 +50003,202 @@ unilaterlly,unilaterally unilatreal,unilateral unilatreally,unilaterally uniliterally,unilaterally +unimpemented,unimplemented +unimplemeneted,unimplemented +unimplimented,unimplemented unimporant,unimportant unimportent,unimportant unimpresed,unimpressed unimpressd,unimpressed unimpresssed,unimpressed uninamous,unanimous +uninfrom,uninform,uniform +uninfromed,uninformed,uniformed +uninfromes,uninforms,uniforms +uninfroming,uninforming,uniforming +uninfroms,uninforms,uniforms +uninitailised,uninitialised +uninitailized,uninitialized +uninitalise,uninitialise uninitalised,uninitialised +uninitalises,uninitialises uninitalizable,uninitializable +uninitalize,uninitialize uninitalized,uninitialized +uninitalizes,uninitializes +uniniteresting,uninteresting +uninitializaed,uninitialized +uninitialse,uninitialise +uninitialsed,uninitialised +uninitialses,uninitialises +uninitialze,uninitialize +uninitialzed,uninitialized +uninitialzes,uninitializes uninsipred,uninspired uninspiried,uninspired uninspried,uninspired +uninstalable,uninstallable uninstaled,uninstalled uninstaling,uninstalling uninstallimg,uninstalling uninstallled,uninstalled uninstallling,uninstalling uninstallng,uninstalling +uninstatiated,uninstantiated unintellegent,unintelligent +unintelligable,unintelligible unintelligant,unintelligent unintelligient,unintelligent unintensional,unintentional unintensionally,unintentionally +unintented,unintended +unintentially,unintentionally unintentinal,unintentional unintentionaly,unintentionally unintentionnal,unintentional unintentionnally,unintentionally uninteresed,uninterested uninteresing,uninteresting +uninteressting,uninteresting uninteristing,uninteresting uninterneted,uninterested +uninterpretted,uninterpreted uninterruped,uninterrupted +uninterruptable,uninterruptible +unintersting,uninteresting +uninteruppted,uninterrupted uninterupted,uninterrupted +unintesting,uninteresting +unintialised,uninitialised +unintialized,uninitialized +unintiallised,uninitialised +unintiallized,uninitialized +unintialsied,uninitialised +unintialzied,uninitialized unintuive,unintuitive +unio,union +unios,unions +uniqe,unique +uniqu,unique uniquelly,uniquely uniquesness,uniqueness uniquey,uniquely uniquiness,uniqueness uniquley,uniquely +uniquness,uniqueness unisntall,uninstall unisntalled,uninstalled unisntalling,uninstalling +uniterrupted,uninterrupted unitesstates,unitedstates +unitialize,uninitialize +unitialized,uninitialized +unitilised,uninitialised +unitilising,uninitialising +unitilities,utilities +unitility,utility +unitilized,uninitialized +unitilizing,uninitializing +unitilties,utilities +unitilty,utility +unititialized,uninitialized +unitss,units univeral,universal +univerally,universally univercity,university +univeriality,universality univerisites,universities univeristies,universities univeristy,university +univerities,universities univerity,university universale,universe universaly,universally universella,universally universels,universes universets,universes +universial,universal +universiality,universality +universirty,university universite,universities universites,universities universitets,universities universitites,universities universse,universes +universtal,universal universtiy,university univesities,universities univesity,university +univrsal,universal unjustifed,unjustified unjustifyed,unjustified +unkmown,unknown +unknon,unknown +unknonw,unknown +unknonwn,unknown +unknonws,unknowns unknowingy,unknowingly unknowinlgy,unknowingly unknowinly,unknowingly +unknwn,unknown +unknwns,unknowns +unknwoing,unknowing +unknwoingly,unknowingly unknwon,unknown +unknwons,unknowns unkonwn,unknown +unkonwns,unknowns unkown,unknown unkowningly,unknowingly +unkowns,unknowns +unkwown,unknown unlcean,unclean +unlcear,unclear unlcoks,unlocks unlcuky,unlucky +unles,unless unliaterally,unilaterally unlikey,unlikely unlikley,unlikely +unlimitied,unlimited +unlimted,unlimited +unline,unlike +unloadins,unloading unlockes,unlocks unluckly,unlucky -unmanouverable,unmaneuverable +unmached,unmatched +unmainted,unmaintained +unmanouverable,unmaneuverable,unmanoeuvrable +unmaping,unmapping +unmappend,unmapped +unmarsalling,unmarshalling +unmistakeably,unmistakably +unmodfide,unmodified +unmodfided,unmodified +unmodfied,unmodified +unmodfieid,unmodified +unmodfified,unmodified +unmodfitied,unmodified +unmodifable,unmodifiable +unmodifed,unmodified +unmoutned,unmounted +unnacquired,unacquired +unncessary,unnecessary unnecassarily,unnecessarily unnecassary,unnecessary +unneccecarily,unnecessarily +unneccecary,unnecessary unneccesarily,unnecessarily unneccesary,unnecessary unneccessarily,unnecessarily unneccessary,unnecessary unnecesarily,unnecessarily +unnecesarrily,unnecessarily +unnecesarry,unnecessary unnecesary,unnecessary unnecessairly,unnecessarily unnecessairy,unnecessarily +unnecessar,unnecessary unnecessarely,unnecessarily unnecessarilly,unnecessarily unnecessarity,unnecessarily @@ -26958,30 +50207,58 @@ unnecesserily,unnecessarily unnecessery,unnecessary unnecissarily,unnecessarily unnecissary,unnecessary +unnecssary,unnecessary +unnedded,unneeded +unneded,unneeded +unneedingly,unnecessarily +unnescessarily,unnecessarily +unnescessary,unnecessary +unnesesarily,unnecessarily +unnessasary,unnecessary unnessecarily,unnecessarily +unnessecarry,unnecessary unnessecary,unnecessary +unnessesarily,unnecessarily +unnessesary,unnecessary +unnessessarily,unnecessarily +unnessessary,unnecessary +unning,running unnistall,uninstall unnistalled,uninstalled unnistalling,uninstalling +unnnecessary,unnecessary +unnsupported,unsupported +unocde,unicode unofficail,unofficial unoffical,unofficial unoffocial,unofficial +unoin,union +unompress,uncompress unopend,unopened unopenend,unopened unoperational,nonoperational +unorderd,unordered unorginial,unoriginal unoriginial,unoriginal unorigional,unoriginal unorignial,unoriginal unorigonal,unoriginal +unorotated,unrotated unoticeable,unnoticeable +unpacke,unpacked +unpacket,unpacked +unparseable,unparsable +unpertubated,unperturbed +unperturbated,unperturbed unplacable,unplayable unplayabe,unplayable unplaybale,unplayable unplayeble,unplayable +unplease,displease unpleaseant,unpleasant unpleasent,unpleasant unplesant,unpleasant +unplesent,unpleasant unpoened,unopened unpopluar,unpopular unpopulair,unpopular @@ -26989,15 +50266,20 @@ unportected,unprotected unprecendented,unprecedented unprecendeted,unprecedented unprecidented,unprecedented +unprecise,imprecise unpredecented,unprecedented +unpredicatable,unpredictable unpredicatble,unpredictable unpredictabe,unpredictable +unpredictablity,unpredictability unpredictible,unpredictable unpreductive,unproductive unprepaired,unprepared unpreparred,unprepared unpresedented,unprecedented unpridictable,unpredictable +unpriviliged,unprivileged +unprmopted,unprompted unproducive,unproductive unproduktive,unproductive unprofessinal,unprofessional @@ -27007,11 +50289,21 @@ unprone,unproven unproteced,unprotected unprotexted,unprotected unqaulified,unqualified +unqiue,unique unqiuely,uniquely unqiueness,uniqueness +unqoute,unquote +unqouted,unquoted +unqoutes,unquotes +unqouting,unquoting unqualifed,unqualified +unque,unique unrakned,unranked unrankend,unranked +unreacahable,unreachable +unreacahble,unreachable +unreacheable,unreachable +unrealeased,unreleased unrealesed,unreleased unrealible,unreliable unrealisitc,unrealistic @@ -27021,57 +50313,183 @@ unrealistisch,unrealistic unrealitic,unrealistic unrealsitic,unrealistic unreaponsive,unresponsive +unreasonabily,unreasonably unreasonablely,unreasonably unreasonabley,unreasonably unreasonablly,unreasonably unreasonal,unreasonably unreasonalby,unreasonably unreasonbly,unreasonably +unrechable,unreachable +unrecocnized,unrecognized +unrecoginized,unrecognized +unrecogized,unrecognized +unrecognixed,unrecognized +unreconized,unrecognized +unrecovable,unrecoverable +unrecovarable,unrecoverable +unrecoverd,unrecovered +unregester,unregister +unregiste,unregister +unregisted,unregistered +unregisteing,registering +unregisterd,unregistered +unregisteres,unregisters +unregistert,unregistered +unregistes,unregisters +unregisting,unregistering +unregistred,unregistered +unregistrs,unregisters +unregiter,unregister +unregiters,unregisters unregluated,unregulated +unregnized,unrecognized +unregognised,unrecognised +unregsiter,unregister +unregsitered,unregistered +unregsitering,unregistering +unregsiters,unregisters +unregster,unregister +unregstered,unregistered +unregstering,unregistering +unregsters,unregisters unregualted,unregulated unregulared,unregulated +unreigister,unregister +unreigster,unregister +unreigstered,unregistered +unreigstering,unregistering +unreigsters,unregisters unrelaible,unreliable -unreleated,unreleased +unrelatd,unrelated +unreleated,unreleased,unrelated unreliabe,unreliable +unrelted,unrelated unrelyable,unreliable +unrelying,underlying unrepentent,unrepentant unrepetant,unrepentant unrepetent,unrepentant +unreplacable,unreplaceable +unreplacalbe,unreplaceable +unreproducable,unreproducible unrepsonsive,unresponsive +unresgister,unregister +unresgisterd,unregistered +unresgistered,unregistered +unresgisters,unregisters +unresonable,unreasonable unresponcive,unresponsive unresponisve,unresponsive unresponive,unresponsive unresponse,unresponsive unresponsibe,unresponsive unresponsivness,unresponsive +unresposive,unresponsive unrestircted,unrestricted unrestrcited,unrestricted unrestriced,unrestricted unrestrictred,unrestricted +unrgesiter,unregister unristricted,unrestricted unrnaked,unranked +unroated,unrotated +unrosponsive,unresponsive unrpoven,unproven unrwitten,unwritten +unsable,unusable,usable,unstable +unsccessful,unsuccessful +unscubscribe,subscribe +unscubscribed,subscribed +unsearcahble,unsearchable unseccessful,unsuccessful -unsed,used +unsed,used,unused +unselcted,unselected +unselctes,unselects +unselcting,unselecting +unselcts,unselects +unselecgt,unselect +unselecgted,unselected +unselecgtes,unselects +unselecgting,unselecting +unselecgts,unselects +unselectabe,unselectable unsencored,uncensored +unsepcified,unspecified +unser,under,unset,unsure,user unsespecting,unsuspecting +unseting,unsetting unsetlling,unsettling +unsettin,unsetting unsettleing,unsettling +unsharable,unshareable unsibscribed,unsubscribed unsibstantiated,unsubstantiated +unsiged,unsigned +unsignificant,insignificant +unsinged,unsigned unsintalled,uninstalled unsistainable,unsustainable +unsoclicited,unsolicited unsolicated,unsolicited unsoliciated,unsolicited unsolicitied,unsolicited unsolicted,unsolicited unsoliticed,unsolicited unsolocited,unsolicited +unspecificed,unspecified +unspefcifieid,unspecified +unspefeid,unspecified +unspeficed,unspecified +unspeficeid,unspecified +unspeficialleid,unspecified +unspeficiallied,unspecified +unspeficiallifed,unspecified +unspeficied,unspecified +unspeficieid,unspecified +unspeficifed,unspecified +unspeficifeid,unspecified +unspeficified,unspecified +unspeficififed,unspecified +unspeficiied,unspecified +unspeficiifed,unspecified +unspeficilleid,unspecified +unspeficillied,unspecified +unspeficillifed,unspecified +unspeficiteid,unspecified +unspeficitied,unspecified +unspeficitifed,unspecified +unspefied,unspecified +unspefifed,unspecified +unspefifeid,unspecified +unspefified,unspecified +unspefififed,unspecified +unspefiied,unspecified +unspefiifeid,unspecified +unspefiified,unspecified +unspefiififed,unspecified +unspefixeid,unspecified +unspefixied,unspecified +unspefixifed,unspecified +unspported,unsupported +unstabel,unstable +unstall,install,uninstall +unstallation,installation,uninstallation +unstalled,installed,uninstalled +unstaller,installer,uninstaller +unstalles,installs,uninstalls +unstalling,installing,uninstalling +unstalls,installs,uninstalls unsuable,unusable +unsual,unusual unsubscibe,unsubscribe +unsubscibed,unsubscribed +unsubscibing,unsubscribing unsubscirbe,unsubscribe unsubscirbed,unsubscribed +unsubscirbing,unsubscribing +unsubscirption,unsubscription +unsubscirptions,unsubscriptions unsubscrbe,unsubscribe unsubscrbed,unsubscribed unsubscribade,unsubscribed @@ -27081,6 +50499,12 @@ unsubscrided,unsubscribed unsubscried,unsubscribed unsubscripe,unsubscribe unsubscriped,unsubscribed +unsubscritpion,unsubscription +unsubscritpions,unsubscriptions +unsubscritpiton,unsubscription +unsubscritpitons,unsubscriptions +unsubscritption,unsubscription +unsubscritptions,unsubscriptions unsubscrive,unsubscribe unsubscrube,unsubscribe unsubscrubed,unsubscribed @@ -27091,17 +50515,45 @@ unsubstansiated,unsubstantiated unsubstantiaed,unsubstantiated unsubstantianted,unsubstantiated unsubstantiative,unsubstantiated +unsucccessful,unsuccessful +unsucccessfully,unsuccessfully +unsucccessul,unsuccessful +unsucccessully,unsuccessfully unsuccesful,unsuccessful +unsuccesfull,unsuccessful unsuccesfully,unsuccessfully unsuccessfull,unsuccessful +unsuccessfullly,unsuccessfully unsuccessul,unsuccessful unsucesful,unsuccessful +unsucesfull,unsuccessful +unsucesfully,unsuccessfully unsucesfuly,unsuccessfully +unsucessefully,unsuccessfully +unsucessflly,unsuccessfully +unsucessfually,unsuccessfully unsucessful,unsuccessful unsucessfull,unsuccessful unsucessfully,unsuccessfully +unsucessfuly,unsuccessfully +unsucesssful,unsuccessful +unsucesssfull,unsuccessful +unsucesssfully,unsuccessfully +unsucesssfuly,unsuccessfully +unsucessufll,unsuccessful +unsucessuflly,unsuccessfully +unsucessully,unsuccessfully +unsued,unused +unsufficient,insufficient unsunscribe,unsubscribe unsunscribed,unsubscribed +unsuportable,unsupportable +unsuported,unsupported +unsupport,unsupported +unsupproted,unsupported +unsupress,unsuppress +unsupressed,unsuppressed +unsupresses,unsuppresses unsuprised,unsurprised unsuprising,unsurprising unsuprisingly,unsurprisingly @@ -27114,20 +50566,50 @@ unsurprizingly,unsurprisingly unsusbcribe,unsubscribe unsusbcribed,unsubscribed unsusbtantiated,unsubstantiated +unsused,unused unsustainble,unsustainable unsustainible,unsustainable unsustianable,unsustainable +unswithced,unswitched +unsychronise,unsynchronise +unsychronised,unsynchronised +unsychronize,unsynchronize +unsychronized,unsynchronized +untargetted,untargeted +unter,under untill,until +untils,until,utils +untintuitive,unintuitive +untoched,untouched +untqueue,unqueue +untrached,untracked untraind,untrained untranslateable,untranslatable +untrasform,untransform +untrasformed,untransformed +untrasposed,untransposed untrianed,untrained +untrustworty,untrustworthy +unued,unused +ununsed,unused +ununsual,unusual unusabe,unusable +unusal,unusual +unusally,unusually unusaully,unusually unuseable,unusable +unuseful,useless +unusre,unsure unusuable,unusable unusualy,unusually +unvailable,unavailable +unvalid,invalid +unvalidate,invalidate unvelievable,unbelievable unvelievably,unbelievably +unverfified,unverified +unversionned,unversioned +unversoned,unversioned unviersally,universally unvierse,universe unvierses,universes @@ -27141,52 +50623,247 @@ unwirtten,unwritten unworhty,unworthy unworthly,unworthy unworty,unworthy +unwraped,unwrapped unwrittern,unwritten +unwrritten,unwritten +unx,unix +unxepected,unexpected +unxepectedly,unexpectedly +unxpected,unexpected +unziped,unzipped +upadate,update +upadated,updated +upadater,updater +upadates,updates +upadating,updating +upadte,update +upadted,updated +upadter,updater +upadters,updaters +upadtes,updates +upagrade,upgrade +upagraded,upgraded +upate,update +upated,updated +upater,updater +upates,updates +upating,updating upcomming,upcoming +updat,update +updateded,updated +updateed,updated +updatees,updates +updateing,updating +updatig,updating +updats,updates +updgrade,upgrade +updrage,upgrade +updte,update +uperclass,upperclass +upgade,upgrade upgarde,upgrade upgarded,upgraded upgardes,upgrades upgarding,upgrading +upgarte,upgrade upgradded,upgraded +upgradei,upgrade +upgradingn,upgrading upgrads,upgrades +upgrate,upgrade +upholstry,upholstery +uplad,upload +upladad,upload,uploaded +upladaded,uploaded +upladed,uploaded +uplader,uploader +upladers,uploaders +uplading,uploading +uplads,uploads +uplaod,upload +uplaodad,upload,uploaded +uplaodaded,uploaded +uplaoded,uploaded +uplaoder,uploader +uplaoders,uploaders +uplaodes,uploads +uplaoding,uploading uplaods,uploads uplfiting,uplifting +upliad,upload uplifitng,uplifting uploades,uploads +uplod,upload +uplodad,upload,uploaded +uplodaded,uploaded +uploded,uploaded +uploder,uploader +uploders,uploaders +uploding,uploading +uplods,uploads +uppler,upper +uppon,upon +upported,supported +upporterd,supported +uppstream,upstream +uppstreamed,upstreamed +uppstreamer,upstreamer +uppstreaming,upstreaming +uppstreams,upstreams +uppwards,upwards +uprade,upgrade +uprgaded,upgraded +upsream,upstream +upsreamed,upstreamed +upsreamer,upstreamer +upsreaming,upstreaming +upsreams,upstreams +upsrteam,upstream +upsrteamed,upstreamed +upsrteamer,upstreamer +upsrteaming,upstreaming +upsrteams,upstreams upstaris,upstairs upsteam,upstream +upsteamed,upstreamed +upsteamer,upstreamer +upsteaming,upstreaming +upsteams,upstreams +upsteram,upstream +upsteramed,upstreamed +upsteramer,upstreamer +upsteraming,upstreaming +upsterams,upstreams upstiars,upstairs +upstread,upstream +upstreamedd,upstreamed +upstreammed,upstreamed +upstreammer,upstreamer +upstreamming,upstreaming +upstreem,upstream +upstreemed,upstreamed +upstreemer,upstreamer +upstreeming,upstreaming +upstreems,upstreams +upstrema,upstream +upsupported,unsupported +uptadeable,updatable +uptdate,update +uptim,uptime +uptions,options +uptream,upstream +uptreamed,upstreamed +uptreamer,upstreamer +uptreaming,upstreaming +uptreams,upstreams urainum,uranium uranuim,uranium +ure,sure,ire,are,urea,rue urethrea,urethra uretrha,urethra urkaine,ukraine urkainian,ukrainian urkainians,ukrainians urnaium,uranium +urrlib,urllib urugauy,uruguay uruguary,uruguay +usal,usual usally,usually +uscaled,unscaled useage,usage +usebility,usability +useble,usable +useed,used +usees,uses +usefule,useful +usefullness,usefulness +usefult,useful usefuly,usefully +usefutl,useful +useg,user,usage +usege,usage useing,using +usera,users +userapace,userspace +userful,useful +userpace,userspace +userpsace,userspace +usersapce,userspace +userspase,userspace +usesfull,useful +usespace,userspace +usetnet,usenet +usibility,usability +usible,usable +usig,using +usign,using,unsign +usiing,using +usin,using +usind,using +usinging,using +usinng,using +usng,using +uspported,supported,unsupported +usseful,useful +ussual,usual +ussuall,usual +ussually,usually +usuable,usable +usuage,usage +usuall,usually,usual +usuallly,usually usualy,usually +usueful,useful +usupported,unsupported +ususal,usual ususally,usually +utiilties,utilities utiliatrian,utilitarian +utilies,utilities +utililties,utilities +utilis,utilise +utilisa,utilise +utilisaton,utilisation utilitatian,utilitarian utiliterian,utilitarian +utilites,utilities +utilitisation,utilisation +utilitise,utilise +utilitises,utilises +utilitising,utilising utilitiy,utility +utilitization,utilization +utilitize,utilize +utilitizes,utilizes +utilitizing,utilizing +utiliz,utilize +utiliza,utilize utilizacion,utilization utilizaiton,utilization utilizating,utilization +utilizaton,utilization +utillities,utilities utiltiarian,utilitarian +utilties,utilities +utiltities,utilities +utiltity,utility utiltiy,utility +utilty,utility +utitity,utility +utitlty,utility utlimate,ultimate utlimately,ultimately utlimatum,ultimatum +utlities,utilities +utlity,utility utlrasound,ultrasound utopain,utopian utpoian,utopian +utput,output +utputs,outputs +uupload,upload +vaalues,values vacciante,vaccinate vacciantion,vaccination vaccinae,vaccinated @@ -27199,21 +50876,40 @@ vaccinet,vaccinated vaccins,vaccines vaccum,vacuum vaccume,vacuum +vaccuum,vacuum vacestomy,vasectomy vacinity,vicinity +vactor,vector +vactors,vectors +vacumme,vacuum +vacuosly,vacuously vageuly,vaguely vaguaries,vagaries vaguelly,vaguely vaguley,vaguely +vaiable,variable +vaiables,variables +vaiant,variant +vaiants,variants vaiation,aviation vaibility,viability +vaid,valid,void vaieties,varieties +vailable,available +vaild,valid vaildated,validated +vailidity,validity vailidty,validity vairable,variable vairables,variables vairant,variant +vairous,various vaklyrie,valkyrie +vakue,value +vakued,valued +vakues,values +valailable,available +valdate,validate valdiated,validated valenca,valencia valenica,valencia @@ -27229,21 +50925,43 @@ valentins,valentines valentis,valentines valentones,valentines valetta,valletta +valiator,validator validade,validated +validaterelase,validaterelease +valide,valid +valididty,validity +validing,validating validitity,validity validitiy,validity +valied,valid +valies,values +valif,valid +valitdity,validity valkirye,valkyrie valkiyre,valkyrie valkriye,valkyrie valkryie,valkyrie +valkues,values valkyire,valkyrie valkyre,valkyrie +vallid,valid +vallidation,validation +vallidity,validity +vallue,value +vallues,values valnecia,valencia valnetines,valentines +valtage,voltage +valtages,voltages +valu,value valuabe,valuable valubale,valuable valuble,valuable +valudes,values valueable,valuable +valuess,values +valuie,value +valuse,values,value valykrie,valkyrie vamipres,vampires vampiers,vampires @@ -27256,26 +50974,70 @@ vanguad,vanguard vangurad,vanguard vanillia,vanilla vanillla,vanilla +vanishs,vanishes vanugard,vanguard +varable,variable +varables,variables +varaiable,variable +varaiables,variables +varaiance,variance +varaiation,variation varaible,variable varaibles,variables varaint,variant varaints,variants +varation,variation varations,variations vareity,variety +variabe,variable variabel,variable +variabele,variable +variabes,variables +varialbles,variables +varian,variant varians,variants variantes,variants +variantions,variations +variatinos,variations +variatoin,variation +variatoins,variations +varibable,variable +varibables,variables varibale,variable +varibales,variables +varibaless,variables +varibel,variable +varibels,variables +varibility,variability +variblae,variable +variblaes,variables +varible,variable +varibles,variables +varience,variance varient,variant +varients,variants +varierty,variety variey,variety varification,verification +variing,varying varing,varying varisty,varsity varitey,variety varities,varieties varity,variety +variuos,various +variuous,various +varius,various +varn,warn +varned,warned +varning,warning +varnings,warnings +varns,warns +varoius,various varstiy,varsity +vartical,vertical +vartically,vertically +vas,was vasall,vassal vasalls,vassals vascetomy,vasectomy @@ -27287,13 +51049,31 @@ vasslas,vassals vastecomy,vasectomy vaticaan,vatican vaticina,vatican +vaue,value vaugely,vaguely vaulable,valuable +vaule,value +vauled,valued +vaules,values +vauling,valuing +vave,have,valve +vavle,valve +vavlue,value +vavriable,variable +vavriables,variables vaylkrie,valkyrie +vbsrcript,vbscript +vebrose,verbose vechiles,vehicles +vecotr,vector vecotrs,vectors +vectore,vector vectores,vectors vectros,vectors +vecvtor,vector +vecvtors,vectors +vedio,video +vefiry,verify veganisim,veganism vegansim,veganism vegatarian,vegetarian @@ -27323,14 +51103,26 @@ vehemontly,vehemently vehicels,vehicles vehicule,vehicle veichles,vehicles +veify,verify veitnam,vietnam veitnamese,vietnamese +veiw,view +veiwed,viewed +veiwer,viewer veiwers,viewers veiwership,viewership +veiwing,viewing +veiwings,viewings veiwpoint,viewpoint veiwpoints,viewpoints +veiws,views +vektor,vector +vektors,vectors velantine,valentine +velidate,validate vell,well +velociries,velocities +velociry,velocity vendeta,vendetta vendettta,vendetta venegance,vengeance @@ -27356,26 +51148,62 @@ verastility,versatility verbaitm,verbatim verbaly,verbally verbatium,verbatim +verbatum,verbatim +verbous,verbose +verbouse,verbose +verbously,verbosely +verbse,verbose +veresion,version +veresions,versions verfication,verification verficiation,verification +verfifiable,verifiable +verfification,verification +verfifications,verifications +verfified,verified +verfifier,verifier +verfifiers,verifiers +verfifies,verifies +verfify,verify +verfifying,verifying verfiying,verifying +verfy,verify +verfying,verifying verical,vertical +verifi,verify,verified +verifiaction,verification verificacion,verification verificaiton,verification verificato,verification +verifie,verify,verified verifikation,verification +verifing,verifying verifiyng,verifying +verifty,verify +veriftying,verifying verifyable,verifiable +verifyied,verified +verion,version +verions,versions +veriosn,version +veriosns,versions verious,various verisions,revisions verison,version +verisoned,versioned verisons,versions +veritcal,vertical veritcally,vertically veritgo,vertigo veritiable,verifiable +veritical,vertical +verly,very vernaculaire,vernacular +verndor,vendor vernecular,vernacular vernicular,vernacular +verrical,vertical +verry,very versalite,versatile versatality,versatility versatel,versatile @@ -27384,29 +51212,74 @@ versatille,versatile versatillity,versatility versatilty,versatility versatily,versatility +vershin,version +versin,version +versio,version +versiob,version +versioed,versioned +versioing,versioning +versiom,version +versionaddded,versionadded versiones,versions +versionm,version +versionms,versions +versionned,versioned +versionning,versioning +versios,versions versitale,versatile versitality,versatility versitilaty,versatility versitlity,versatility versoin,version +verson,version +versoned,versioned +versons,versions verstaile,versatile vertabim,verbatim +vertextes,vertices +vertexts,vertices vertgio,vertigo +vertial,vertical +verticall,vertical verticallity,vertically verticaly,vertically -vertification,certification +verticies,vertices +verticle,vertical +verticlealign,verticalalign +vertiece,vertex +vertieces,vertices +vertifiable,verifiable +vertification,certification,verification +vertifications,verifications +vertify,verify vertigro,vertigo +vertikal,vertical +vertix,vertex +vertixes,vertices +vertixs,vertices +veryfieng,verifying +veryfy,verify +veryified,verified +veryifies,verifies veryifing,verifying +veryify,verify +veryifying,verifying +vesion,version +vesions,versions vesseles,vessels vessells,vessels vessles,vessels +vetex,vertex +vetexes,vertices vetween,between +vew,view vewiership,viewership veyr,very +vhild,child viabiliy,viability viatmin,vitamin viatmins,vitamins +viatnamese,vietnamese vibratie,vibrate vibratin,vibration vibratoare,vibrator @@ -27441,13 +51314,17 @@ videogaems,videogames videogamemes,videogames videogams,videogames videojames,videogames +videostreamming,videostreaming vidoegame,videogame vidoegames,videogames vientam,vietnam vientamese,vietnamese +vieport,viewport +vieports,viewports vietmanese,vietnamese vietnamees,vietnamese vietnameese,vietnamese +vietnamesea,vietnamese vietnamesse,vietnamese vietnamiese,vietnamese vietnamnese,vietnamese @@ -27455,7 +51332,8 @@ vieweres,viewers viewpiont,viewpoint viewpionts,viewpoints viewpoit,viewpoints -vigeur,vigueur +viewtransfromation,viewtransformation +vigeur,vigueur,vigour,vigour vigilane,vigilante vigilantie,vigilante vigilanties,vigilante @@ -27470,23 +51348,31 @@ vikigns,vikings vikingos,vikings viligant,vigilant viligante,vigilante +vill,will villageois,villages villegas,villages villian,villain villification,vilification villify,vilify -villin,villain +villin,villain,villi,villein viloently,violently vincinity,vicinity vindicitve,vindictive vindictave,vindictive vindicte,vindictive vinicity,vicinity +vinrator,vibrator +vioalte,violate vioalting,violating +vioaltion,violation violatin,violation violentce,violence violenty,violently violetas,violates +violoated,violated +violoating,violating +violoation,violation +violoations,violations virament,vraiment virbate,vibrate virbation,vibration @@ -27499,31 +51385,102 @@ virgintiy,virginity virginus,virgins virignity,virginity virigns,virgins +virtal,virtual +virtaul,virtual +virtical,vertical virtiol,vitriol +virtiual,virtual +virtualisaion,virtualisation +virtualisaiton,virtualisation +virtualizaion,virtualization +virtualizaiton,virtualization +virtualiziation,virtualization virtualy,virtually +virtuell,virtual virtuels,virtues virtuose,virtues +virtural,virtual +virture,virtue +virual,virtual,viral virualization,visualization virutal,virtual +virutalenv,virtualenv +virutalisation,virtualisation +virutalise,virtualise +virutalised,virtualised +virutalization,virtualization +virutalize,virtualize +virutalized,virtualized virutally,virtually +virutals,virtuals virutes,virtues +visability,visibility visable,visible visably,visibly visbily,visibly +visble,visible +visblie,visible +visbly,visibly viscreal,visceral visercal,visceral +visiable,visible +visiably,visibly +visibale,visible +visibile,visible visibiliy,visibility visibillity,visibility visibiltiy,visibility +visibilty,visibility visibily,visibility +visibleable,visible +visibles,visible visibley,visibly +visiblities,visibilities +visiblity,visibility +visiblle,visible visiblly,visibly +visinble,visible +visious,vicious +visisble,visible +visiter,visitor +visiters,visitors +visitng,visiting +visivble,visible +vissible,visible +visted,visited visting,visiting vistors,visitors +visuab,visual +visuabisation,visualisation +visuabise,visualise +visuabised,visualised +visuabises,visualises +visuabization,visualization +visuabize,visualize +visuabized,visualized +visuabizes,visualizes +visuable,visual,visible +visuables,visuals +visuably,visually +visuabs,visuals +visuaisation,visualisation +visuaise,visualise +visuaised,visualised +visuaises,visualises +visuaization,visualization +visuaize,visualize +visuaized,visualized +visuaizes,visualizes +visuale,visual +visuales,visuals visualizacion,visualization visualizaiton,visualization visualizating,visualization visualizaton,visualization +visuallisation,visualisation +visuallization,visualization +visualy,visually +visualyse,visualise,visualise vitailty,vitality vitaliy,vitality vitaminas,vitamins @@ -27540,9 +51497,26 @@ vitroil,vitriol vitrual,virtual vitrually,virtually vitrues,virtues +vitual,virtual vitualization,visualization +viusally,visually +viusualisation,visualisation +viwer,viewer +viwers,viewers +vizualisation,visualisation vizualisations,visualisation +vizualise,visualise +vizualised,visualised vizualization,visualization +vizualize,visualize +vizualized,visualized +vlarge,large +vlaue,value +vlaues,values +vlone,clone +vloned,cloned +vlones,clones +vlues,values vocabluary,vocabulary vocabularily,vocabulary vocabularity,vocabulary @@ -27553,7 +51527,10 @@ voilates,violates voilating,violating voilation,violation voilently,violently +volatage,voltage +volatages,voltages volatge,voltage +volatges,voltages volatiliy,volatility volatillity,volatility volatiltiy,volatility @@ -27562,6 +51539,9 @@ volativity,volatility volcando,volcano volcanoe,volcano volcaron,volcano +volenteer,volunteer +volenteered,volunteered +volenteers,volunteers voleyball,volleyball volitality,volatility volleyboll,volleyball @@ -27576,6 +51556,7 @@ volounteered,volunteered volounteering,volunteering volounteers,volunteers volumne,volume +volums,volume volunatrily,voluntarily volunatry,voluntary voluntairly,voluntarily @@ -27592,30 +51573,135 @@ voluntered,volunteered voluntereed,volunteered volunterily,voluntarily volunterring,volunteering +vonfig,config votlage,voltage +vould,would +voxes,voxels,voxel vreity,variety +vresion,version vrey,very +vriable,variable +vriables,variables vriament,vraiment vriety,variety +vrifies,verifies +vrify,verify vriginity,virginity vrigins,virgins +vrilog,verilog +vritual,virtual +vritualenv,virtualenv +vritualisation,virtualisation +vritualise,virtualise +vritualization,virtualization +vritualize,virtualize +vrituoso,virtuoso +vrsion,version +vrsions,versions +vulacn,vulcan +vulakn,vulkan +vulbearable,vulnerable +vulbearabule,vulnerable +vulbearbilities,vulnerabilities +vulbearbility,vulnerability +vulbearbuilities,vulnerabilities +vulbearbuility,vulnerability +vulberabilility,vulnerability +vulberabilites,vulnerabilities +vulberabiliti,vulnerability +vulberabilitie,vulnerability +vulberabilitis,vulnerabilities +vulberabilitiy,vulnerability vulberability,vulnerability +vulberabillities,vulnerabilities +vulberabillity,vulnerability +vulberabilties,vulnerabilities +vulberabilty,vulnerability +vulberablility,vulnerability +vulberabuilility,vulnerability +vulberabuilites,vulnerabilities +vulberabuiliti,vulnerability +vulberabuilitie,vulnerability +vulberabuilities,vulnerabilities +vulberabuilitis,vulnerabilities +vulberabuilitiy,vulnerability +vulberabuility,vulnerability +vulberabuillities,vulnerabilities +vulberabuillity,vulnerability +vulberabuilties,vulnerabilities +vulberabuilty,vulnerability +vulberabule,vulnerable +vulberabulility,vulnerability +vulberbilities,vulnerabilities +vulberbility,vulnerability +vulberbuilities,vulnerabilities +vulberbuility,vulnerability +vulerabilities,vulnerabilities +vulerability,vulnerability +vulerable,vulnerable +vulerabuilities,vulnerabilities +vulerabuility,vulnerability +vulerabule,vulnerable vulernabilities,vulnerabilities vulernability,vulnerability vulernable,vulnerable vulnarabilities,vulnerabilities vulnarability,vulnerability vulnarable,vulnerable +vulneabilities,vulnerabilities +vulneability,vulnerability +vulneable,vulnerable +vulnearabilities,vulnerabilities +vulnearability,vulnerability +vulnearable,vulnerable +vulnearabule,vulnerable +vulnearbilities,vulnerabilities +vulnearbility,vulnerability +vulnearbuilities,vulnerabilities +vulnearbuility,vulnerability vulnerabil,vulnerable vulnerabile,vulnerable +vulnerabilility,vulnerability vulnerabilites,vulnerabilities +vulnerabiliti,vulnerability +vulnerabilitie,vulnerability +vulnerabilitis,vulnerabilities +vulnerabilitiy,vulnerability +vulnerabilitu,vulnerability +vulnerabiliy,vulnerability +vulnerabillities,vulnerabilities vulnerabillity,vulnerability +vulnerabilties,vulnerabilities vulnerabiltiy,vulnerability vulnerabilty,vulnerability vulnerablility,vulnerability +vulnerablities,vulnerabilities +vulnerablity,vulnerability +vulnerabuilility,vulnerability +vulnerabuilites,vulnerabilities +vulnerabuiliti,vulnerability +vulnerabuilitie,vulnerability +vulnerabuilities,vulnerabilities +vulnerabuilitis,vulnerabilities +vulnerabuilitiy,vulnerability +vulnerabuility,vulnerability +vulnerabuillities,vulnerabilities +vulnerabuillity,vulnerability +vulnerabuilties,vulnerabilities +vulnerabuilty,vulnerability +vulnerabule,vulnerable +vulnerabulility,vulnerability +vulnerarbilities,vulnerabilities +vulnerarbility,vulnerability +vulnerarble,vulnerable +vulnerbilities,vulnerabilities +vulnerbility,vulnerability +vulnerbuilities,vulnerabilities +vulnerbuility,vulnerability vulnurabilities,vulnerabilities vulnurability,vulnerability vulnurable,vulnerable +vunerable,vulnerable vunlerabilities,vulnerabilities vunlerability,vulnerability vunlerable,vulnerable @@ -27628,16 +51714,51 @@ wacther,watcher waht,what wahtever,whatever waitres,waiters +wakeus,wakeups,walrus waktins,watkins +wakup,wakeup wallpapaers,wallpapers wallpapes,wallpapers wallpappers,wallpapers wallpapr,wallpapers +wappers,wrappers warantee,warranty +waranties,warranties +waranty,warranty warcarft,warcraft warcrat,warcraft wardobe,wardrobe +waring,warning +warinigs,warnings +warinings,warnings wariwck,warwick +warks,works +warlking,walking +warnibg,warning +warnibgs,warnings +warnig,warning +warnign,warning +warnigns,warnings +warnigs,warnings +warniing,warning +warniings,warnings +warnin,warning +warnind,warning +warninds,warnings +warninf,warning +warninfs,warnings +warningss,warnings +warninig,warning +warninigs,warnings +warnining,warning +warninings,warnings +warninng,warning +warninngs,warnings +warnins,warnings +warninsg,warnings +warninsgs,warnings +warniong,warning +warniongs,warnings warrandyte,warranty warrante,warranties warrantles,warranties @@ -27651,19 +51772,28 @@ warrriors,warriors warwcik,warwick washignton,washington washingtion,washington +wasn,was wass,was +watchdong,watchdog watchemn,watchmen watchign,watching +watchog,watchdog waterlemon,watermelon watermalon,watermelon +watermask,watermark watermeleon,watermelon waterproff,waterproof waterprooof,waterproof +wath,watch,wrath,what +wathc,watch wathcer,watcher wathcing,watching wathcmen,watchmen +wathdog,watchdog wathever,whatever +waths,whats,watches watiers,waiters +wating,waiting watkings,watkins watn,want wavelegnth,wavelength @@ -27672,7 +51802,8 @@ wavelengh,wavelength wavelenghs,wavelength wavelenght,wavelength wavelenghth,wavelength -wavelenghts,wavelength +wavelenghts,wavelength,wavelengths +wavelnes,wavelines waviers,waivers wawrick,warwick wayword,wayward @@ -27684,6 +51815,7 @@ weaknesss,weaknesses weaknessses,weaknesses wealtheir,wealthier wealthly,wealthy +weant,want,wean weaponary,weaponry weas,was weathliest,wealthiest @@ -27694,6 +51826,7 @@ webstie,website websties,websites wedensday,wednesday wedensdays,wednesdays +wednesdaay,wednesday wednesdsay,wednesdays wednesdsy,wednesdays wednesdy,wednesdays @@ -27701,19 +51834,26 @@ wednessay,wednesdays wednessday,wednesdays wednseday,wednesday wednsedays,wednesdays +wege,wedge +wehere,where wehn,when +wehther,whether weightened,weighted weightlfiting,weightlifting weightlifing,weightlifting weightlifitng,weightlifting weightligting,weightlifting +weigth,weight weigthed,weighted weigthlifting,weightlifting weigths,weights -weild,wield +weild,wield,wild weilded,wielded +weill,will +weired,weird weirldy,weirdly weirods,weirdos +weitght,weight welathier,wealthier welathiest,wealthiest welathy,wealthy @@ -27727,11 +51867,15 @@ wendsay,wednesday wensday,wednesday wepbage,webpage wereabouts,whereabouts +wereas,whereas +weree,were +werever,wherever weridest,weirdest weridly,weirdly weridos,weirdos werstle,wrestle werstler,wrestler +wery,very,wary,weary wesbite,website wesbites,websites wesbtrook,westbrook @@ -27748,25 +51892,63 @@ westmisnter,westminster westmnister,westminster westmonster,westminster westrbook,westbrook +wether,weather,whether +wew,we whaeton,wheaton +whan,want,when whant,want whants,wants +whataver,whatever +whatepsace,whitespace +whatepsaces,whitespaces +whather,whether,weather whatosever,whatsoever whatseover,whatsoever +whch,which whcih,which +whe,when,we +wheather,weather,whether +whehter,whether +wheigh,weigh +whell,wheel,well +whenevery,whenever +whenver,whenever +wher,where wheras,whereas wherease,whereas whereever,wherever +wherether,whether +whery,where +wheteher,whether +whetehr,whether wheter,whether +whethe,whether +whethter,whether +whheel,wheel whic,which +whicg,which +whicht,which whietlist,whitelist whihc,which +whihch,which +whike,while +whilest,whilst whilrwind,whirlwind whilsting,whistling +whiltelist,whitelist +whiltelisted,whitelisted +whiltelisting,whitelisting +whiltelists,whitelists +whilw,while +whioch,which +whiped,whipped,wiped whipser,whisper whipsered,whispered whipsering,whispering whipsers,whispers +whis,this,whisk +whish,wish,whisk +whishlist,wishlist whislist,wishlist whislte,whistle whisltes,whistles @@ -27776,22 +51958,39 @@ whisperered,whispered whisperes,whispers whistel,whistle whistels,whistles +whitch,which +whitchever,whichever whitelsit,whitelist +whitepsace,whitespace +whitepsaces,whitespaces whith,with +whithe,with,white +whithin,within whitholding,withholding +whithout,without whitleist,whitelist +whitout,without,whiteout +whitre,white whitsle,whistle whitsles,whistles whitsling,whistling +whitspace,whitespace whlch,which +whle,while +whlie,while whn,when +whne,when +whoes,whose wholeheartadly,wholeheartedly wholeheartdly,wholeheartedly wholeheartedy,wholeheartedly wholeheartely,wholeheartedly wholeheartidly,wholeheartedly wholey,wholly -wholy,wholly +wholy,wholly,holy +whoose,whose +whos,whose +whould,would whrilwind,whirlwind whsiper,whisper whsipered,whispered @@ -27800,27 +51999,61 @@ whsipers,whispers whta,what whther,whether whtielist,whitelist +whtihin,within +whyth,with +whythout,without +wiat,wait wiaters,waiters wiavers,waivers +wice,vice wich,which widepsread,widespread widespred,widespread widesread,widespread +widged,widget widgest,widgets widgetas,widgets +widgit,widget +widht,width +widhtpoint,widthpoint +widhtpoints,widthpoints +widthn,width +widthout,without wief,wife -wieghted,weighted +wieghed,weighed +wieght,weight +wieghted,weighted,weighed wieghtlifting,weightlifting wieghts,weights +wieh,view wierd,weird +wierdly,weirdly +wierdness,weirdness +wieth,width wiew,view +wigdet,widget wigdets,widgets +wighed,weighed,wicked +wighted,weighted,weighed wih,with +wihch,which +wihich,which +wihite,white +wihle,while +wihout,without wiht,with +wihtin,within +wihtout,without +wiil,will wikileakers,wikileaks wikileakes,wikileaks +wikpedia,wikipedia +wil,will,well +wilcard,wildcard +wilcards,wildcards wilderniss,wilderness wildreness,wilderness +wilh,will willaims,williams wille,will willfullly,willfully @@ -27828,24 +52061,46 @@ willfuly,willfully willimas,williams willingless,willingness willk,will +willl,will wincheseter,winchester winchestor,winchester windhsield,windshield +windo,window +windoes,windows +windoow,window +windoows,windows +windos,windows windosr,windsor windsheild,windshield windsheilds,windshield windshied,windshield windshiled,windshield windsoar,windsor +windwo,window wininpeg,winnipeg +winn,win +winndow,window +winndows,windows winnigns,winnings winnins,winnings winnpieg,winnipeg +winodw,window winsdor,windsor wintesses,witnesses wintson,winston +wipoing,wiping +wirded,wired,weird wiredest,weirdest +wirh,with +wirtable,writable,writeable +wirte,write +wirter,writer +wirters,writers +wirtes,writes +wirth,with,worth wirting,writing +wirtten,written +wirtual,virtual wisconisn,wisconsin wisconsion,wisconsin wishlisht,wishlist @@ -27854,6 +52109,10 @@ wishpered,whispered wishpering,whispering wishpers,whispers wisnton,winston +witable,writeable +witdh,width +wite,write,white +witha,with withces,witches withdral,withdrawal withdrawalls,withdrawals @@ -27861,7 +52120,7 @@ withdrawan,withdrawn withdrawel,withdrawal withdrawels,withdrawals withdrawin,withdrawn -withdrawl,withdrawal +withdrawl,withdrawal,withdraw withdrawles,withdrawals withdrawling,withdrawing withdrawning,withdrawing @@ -27870,63 +52129,186 @@ withelist,whitelist withh,with withhelding,withholding withholdng,withholding +withih,within withing,within +withinn,within +withion,within +witho,with +withoit,without withold,withhold +witholding,withholding +withon,within +withoout,without +withot,without +withotu,without +withou,without +withoud,without +withoug,without +withough,without +withought,without +withouht,without +withount,without +withour,without +withourt,without +withous,without +withouth,without +withouyt,without +withput,without withrdawal,withdrawals withrdawing,withdrawing +withs,with,widths witht,with +witin,within +witk,with witn,with witnesess,witnesses witnesss,witnesses witnesssing,witnessing witnissing,witnessing +witout,without +witth,with wiull,will +wiyh,with +wiyhout,without +wiyth,with +wizzard,wizard +wjat,what wlacott,walcott -wnat,want +wll,will +wnat,want,what wnated,wanted +wnating,wanting wnats,wants +wnen,when,wen +wnidow,window,widow +wnidows,windows,widows +woh,who wohle,whole +woill,will +woithout,without wokr,work wokring,working +wollow,follow,wallow +wollowing,following,wallowing +wolrd,world +wolrdly,worldly wolrdview,worldview wolrdwide,worldwide +wolwide,worldwide +womens,women wonderes,wonders wonderfull,wonderful wonderfullly,wonderfully wonderfuly,wonderfully +wonderig,wondering wonderlad,wonderland wonderus,wonders wonderwand,wonderland woodowrking,woodworking woodworkign,woodworking +woraround,workaround +worarounds,workarounds +worbench,workbench +worbenches,workbenches wordlview,worldview wordlwide,worldwide +wordpres,wordpress +worfklow,workflow +worfklows,workflows +worflow,workflow +worflows,workflows worhsiping,worshiping worhsipping,worshipping worhtless,worthless +workaorund,workaround +workaound,workaround +workaounds,workarounds +workaraound,workaround +workaraounds,workarounds +workarbound,workaround +workaroud,workaround +workarouds,workarounds +workarould,workaround +workaroung,workaround +workaroungs,workarounds +workarround,workaround +workarrounds,workarounds +workarund,workaround +workarunds,workarounds +workbanch,workbench +workbanches,workbenches +workbanchs,workbenches +workbenchs,workbenches +workbennch,workbench +workbennches,workbenches +workbnech,workbench +workbneches,workbenches +workboos,workbooks +workd,worked +worke,work,worked,works +workes,works workfore,workforce +workfow,workflow +workfows,workflows workfroce,workforce +workign,working workingest,workings workins,workings +worklfow,workflow +worklfows,workflows +workpsace,workspace +workpsaces,workspaces +workspsace,workspace +workspsaces,workspaces workstaion,workstation +workstaions,workstations +workstaition,workstation +workstaitions,workstations workstaiton,workstation +workstaitons,workstations workstaton,workstation workststion,workstation +workststions,workstations worldivew,worldview worldveiw,worldview +worload,workload +worloads,workloads worls,world +worng,wrong,worn +wornged,wronged +worngs,wrongs +worser,worse worshippig,worshipping worshippping,worshipping worshoping,worshiping worshopping,worshipping worstened,worsened worthelss,worthless +worthing,worth,meriting +worthwile,worthwhile +woth,worth +wothout,without +woud,would woudl,would woudlnt,wouldnt woudlve,wouldve wouldnot,wouldnt woulndt,wouldnt +wounderful,wonderful +wouold,would +wouuld,would +wqs,was +wraning,warning +wranings,warnings wranlger,wrangler +wraped,wrapped,warped +wrapepd,wrapped +wraper,wrapper +wraping,wrapping,warping +wrapp,wrap +wrappered,wrapped +wrappng,wrapping +wrapps,wraps wreckign,wrecking wrecthed,wretched wrekcing,wrecking @@ -27935,16 +52317,49 @@ wreslter,wrestler wresters,wrestlers wrestlewar,wrestler wriet,write +writebufer,writebuffer +writechetque,writecheque +writeing,writing writen,written +writet,writes +writewr,writer +writingm,writing +writter,writer +writters,writers +writtin,written,writing writting,writing +writtten,written +wrkload,workload +wrkloads,workloads wrnagler,wrangler +wrod,word wroet,wrote +wrog,wrong wrok,work +wroked,worked +wrokflow,workflow +wrokflows,workflows wroking,working +wrokload,workload +wrokloads,workloads +wroks,works +wron,wrong +wronf,wrong +wront,wrong wrteched,wretched +wrtie,write +wrting,writing +wsee,see +wth,with wtiches,witches wtih,with +wuold,would wupport,support +wya,way +wyth,with +wythout,without +xdescribe,describe +xdpf,xpdf xenbolade,xenoblade xenobalde,xenoblade xenohpobic,xenophobic @@ -27959,19 +52374,39 @@ xenophopic,xenophobic xeonblade,xenoblade xeonphobia,xenophobia xeonphobic,xenophobic +xepect,expect +xepected,expected +xepectedly,expectedly +xepecting,expecting +xepects,expects +xgetttext,xgettext +xinitiazlize,xinitialize +xmdoel,xmodel +xour,your +xyou,you yaching,yachting yaer,year yaerly,yearly yaers,years yatch,yacht +yau,you,yaw yearm,year yeasr,years yeild,yield +yeilded,yielded yeilding,yielding -yementite,yemenite +yeilds,yields +yeld,yield +yelded,yielded +yelding,yielding +yelds,yields +yementite,yemenite,yemeni yera,year yeras,years yersa,years +yhe,the +yieldin,yielding +ymbols,symbols yoesmite,yosemite yorksher,yorkshire yorkshie,yorkshire @@ -27981,16 +52416,27 @@ yosemeti,yosemite yosemitie,yosemite yosimete,yosemite yotube,youtube +youn,your,you,young youngents,youngest younget,youngest +youre,your +yourr,your +yourselfe,yourself,yourselves yourselfes,yourselves +yourselv,yourself,yourselves +yourselve,yourselves,yourself yourselvs,yourselves yoursleves,yourselves -youseff,yousef +youseff,yousef,yourself youself,yourself +ypes,types yrea,year +yse,yes,use,nyse ytou,you +yugoslac,yugoslav yuo,you +yuor,your +yur,your zaelots,zealots zealotes,zealots zealoths,zealots @@ -28007,6 +52453,8 @@ zimbabew,zimbabwe zimbabwae,zimbabwe zimbabwaen,zimbabwe zimbawbe,zimbabwe +zimmap,zipmap +zimpaps,zipmaps zinoists,zionists zionisim,zionism zionistas,zionists @@ -28016,6 +52464,22 @@ zionistm,zionism zionsim,zionism zionsit,zionist zionsits,zionists +ziped,zipped +ziper,zipper +ziping,zipping +zlot,slot zoinism,zionism zoinist,zionist zoinists,zionists +zombe,zombie +zomebie,zombie +zuser,user +évaluate,evaluate +сontain,contain +сontained,contained +сontainer,container +сontainers,containers +сontaining,containing +сontainor,container +сontainors,containers +сontains,contains diff --git a/crates/typos-dict/src/dict_codegen.rs b/crates/typos-dict/src/dict_codegen.rs index ef42b94..38a0c91 100644 --- a/crates/typos-dict/src/dict_codegen.rs +++ b/crates/typos-dict/src/dict_codegen.rs @@ -4,13 +4,37 @@ pub static WORD_TRIE: dictgen::DictTrie<&'static [&'static str]> = dictgen::DictTrie { root: &WORD_NODE, unicode: &WORD_UNICODE_TABLE, - range: 3..=19, + range: 2..=34, }; pub static WORD_UNICODE_TABLE: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[], - values: &[], - range: 0..=0, + 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 { @@ -70,6 +94,8 @@ pub static WORD_Z_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge dictgen::InsensitiveStr::Ascii("imbabwae"), dictgen::InsensitiveStr::Ascii("imbabwaen"), dictgen::InsensitiveStr::Ascii("imbawbe"), + dictgen::InsensitiveStr::Ascii("immap"), + dictgen::InsensitiveStr::Ascii("impaps"), dictgen::InsensitiveStr::Ascii("inoists"), dictgen::InsensitiveStr::Ascii("ionisim"), dictgen::InsensitiveStr::Ascii("ionistas"), @@ -79,9 +105,16 @@ pub static WORD_Z_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge dictgen::InsensitiveStr::Ascii("ionsim"), dictgen::InsensitiveStr::Ascii("ionsit"), dictgen::InsensitiveStr::Ascii("ionsits"), + dictgen::InsensitiveStr::Ascii("iped"), + dictgen::InsensitiveStr::Ascii("iper"), + dictgen::InsensitiveStr::Ascii("iping"), + dictgen::InsensitiveStr::Ascii("lot"), dictgen::InsensitiveStr::Ascii("oinism"), dictgen::InsensitiveStr::Ascii("oinist"), dictgen::InsensitiveStr::Ascii("oinists"), + dictgen::InsensitiveStr::Ascii("ombe"), + dictgen::InsensitiveStr::Ascii("omebie"), + dictgen::InsensitiveStr::Ascii("user"), ], values: &[ &["zealots"], @@ -100,6 +133,8 @@ pub static WORD_Z_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge &["zimbabwe"], &["zimbabwe"], &["zimbabwe"], + &["zipmap"], + &["zipmaps"], &["zionists"], &["zionism"], &["zionists"], @@ -109,11 +144,18 @@ pub static WORD_Z_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge &["zionism"], &["zionist"], &["zionists"], + &["zipped"], + &["zipper"], + &["zipping"], + &["slot"], &["zionism"], &["zionist"], &["zionists"], + &["zombie"], + &["zombie"], + &["user"], ], - range: 5..=9, + range: 3..=9, }; static WORD_Y_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -128,14 +170,24 @@ pub static WORD_Y_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge dictgen::InsensitiveStr::Ascii("aerly"), dictgen::InsensitiveStr::Ascii("aers"), dictgen::InsensitiveStr::Ascii("atch"), + dictgen::InsensitiveStr::Ascii("au"), dictgen::InsensitiveStr::Ascii("earm"), dictgen::InsensitiveStr::Ascii("easr"), dictgen::InsensitiveStr::Ascii("eild"), + dictgen::InsensitiveStr::Ascii("eilded"), dictgen::InsensitiveStr::Ascii("eilding"), + dictgen::InsensitiveStr::Ascii("eilds"), + dictgen::InsensitiveStr::Ascii("eld"), + dictgen::InsensitiveStr::Ascii("elded"), + dictgen::InsensitiveStr::Ascii("elding"), + dictgen::InsensitiveStr::Ascii("elds"), dictgen::InsensitiveStr::Ascii("ementite"), dictgen::InsensitiveStr::Ascii("era"), dictgen::InsensitiveStr::Ascii("eras"), dictgen::InsensitiveStr::Ascii("ersa"), + dictgen::InsensitiveStr::Ascii("he"), + dictgen::InsensitiveStr::Ascii("ieldin"), + dictgen::InsensitiveStr::Ascii("mbols"), dictgen::InsensitiveStr::Ascii("oesmite"), dictgen::InsensitiveStr::Ascii("orksher"), dictgen::InsensitiveStr::Ascii("orkshie"), @@ -145,16 +197,27 @@ pub static WORD_Y_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge dictgen::InsensitiveStr::Ascii("osemitie"), dictgen::InsensitiveStr::Ascii("osimete"), dictgen::InsensitiveStr::Ascii("otube"), + dictgen::InsensitiveStr::Ascii("oun"), dictgen::InsensitiveStr::Ascii("oungents"), dictgen::InsensitiveStr::Ascii("ounget"), + dictgen::InsensitiveStr::Ascii("oure"), + dictgen::InsensitiveStr::Ascii("ourr"), + dictgen::InsensitiveStr::Ascii("ourselfe"), dictgen::InsensitiveStr::Ascii("ourselfes"), + dictgen::InsensitiveStr::Ascii("ourselv"), + dictgen::InsensitiveStr::Ascii("ourselve"), dictgen::InsensitiveStr::Ascii("ourselvs"), dictgen::InsensitiveStr::Ascii("oursleves"), dictgen::InsensitiveStr::Ascii("ouseff"), dictgen::InsensitiveStr::Ascii("ouself"), + dictgen::InsensitiveStr::Ascii("pes"), dictgen::InsensitiveStr::Ascii("rea"), + dictgen::InsensitiveStr::Ascii("se"), dictgen::InsensitiveStr::Ascii("tou"), + dictgen::InsensitiveStr::Ascii("ugoslac"), dictgen::InsensitiveStr::Ascii("uo"), + dictgen::InsensitiveStr::Ascii("uor"), + dictgen::InsensitiveStr::Ascii("ur"), ], values: &[ &["yachting"], @@ -162,14 +225,24 @@ pub static WORD_Y_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge &["yearly"], &["years"], &["yacht"], + &["you", "yaw"], &["year"], &["years"], &["yield"], + &["yielded"], &["yielding"], - &["yemenite"], + &["yields"], + &["yield"], + &["yielded"], + &["yielding"], + &["yields"], + &["yemenite", "yemeni"], &["year"], &["years"], &["years"], + &["the"], + &["yielding"], + &["symbols"], &["yosemite"], &["yorkshire"], &["yorkshire"], @@ -179,16 +252,27 @@ pub static WORD_Y_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge &["yosemite"], &["yosemite"], &["youtube"], + &["your", "you", "young"], &["youngest"], &["youngest"], + &["your"], + &["your"], + &["yourself", "yourselves"], + &["yourselves"], + &["yourself", "yourselves"], + &["yourselves", "yourself"], &["yourselves"], &["yourselves"], - &["yourselves"], - &["yousef"], + &["yousef", "yourself"], &["yourself"], + &["types"], &["year"], + &["yes", "use", "nyse"], &["you"], + &["yugoslav"], &["you"], + &["your"], + &["your"], ], range: 2..=9, }; @@ -200,6 +284,8 @@ static WORD_X_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di 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"), @@ -214,8 +300,20 @@ pub static WORD_X_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge 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("our"), + dictgen::InsensitiveStr::Ascii("you"), ], values: &[ + &["describe"], + &["xpdf"], &["xenoblade"], &["xenoblade"], &["xenophobic"], @@ -230,8 +328,18 @@ pub static WORD_X_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictge &["xenoblade"], &["xenophobia"], &["xenophobic"], + &["expect"], + &["expected"], + &["expectedly"], + &["expecting"], + &["expects"], + &["xgettext"], + &["xinitialize"], + &["xmodel"], + &["your"], + &["you"], ], - range: 8..=11, + range: 3..=11, }; static WORD_W_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -249,34 +357,52 @@ static WORD_W_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_WH_NODE), Some(&WORD_WI_NODE), - None, + Some(&WORD_WJ_NODE), None, Some(&WORD_WL_NODE), None, Some(&WORD_WN_NODE), Some(&WORD_WO_NODE), None, - None, + Some(&WORD_WQ_NODE), Some(&WORD_WR_NODE), - None, + Some(&WORD_WS_NODE), Some(&WORD_WT_NODE), Some(&WORD_WU_NODE), None, 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("pport")], - values: &[&["support"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("old"), + dictgen::InsensitiveStr::Ascii("pport"), + ], + values: &[&["would"], &["support"]], + range: 3..=5, }; static WORD_WT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -286,11 +412,23 @@ static WORD_WT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), ], - values: &[&["witches"], &["with"]], - range: 2..=5, + values: &[&["with"], &["witches"], &["with"]], + 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")], + values: &[&["see"]], + range: 2..=2, }; static WORD_WR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -300,7 +438,17 @@ static WORD_WR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_WR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("aning"), + dictgen::InsensitiveStr::Ascii("anings"), dictgen::InsensitiveStr::Ascii("anlger"), + dictgen::InsensitiveStr::Ascii("aped"), + dictgen::InsensitiveStr::Ascii("apepd"), + dictgen::InsensitiveStr::Ascii("aper"), + dictgen::InsensitiveStr::Ascii("aping"), + dictgen::InsensitiveStr::Ascii("app"), + dictgen::InsensitiveStr::Ascii("appered"), + dictgen::InsensitiveStr::Ascii("appng"), + dictgen::InsensitiveStr::Ascii("apps"), dictgen::InsensitiveStr::Ascii("eckign"), dictgen::InsensitiveStr::Ascii("ecthed"), dictgen::InsensitiveStr::Ascii("ekcing"), @@ -309,16 +457,51 @@ pub static WORD_WR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("esters"), dictgen::InsensitiveStr::Ascii("estlewar"), dictgen::InsensitiveStr::Ascii("iet"), + dictgen::InsensitiveStr::Ascii("itebufer"), + dictgen::InsensitiveStr::Ascii("itechetque"), + dictgen::InsensitiveStr::Ascii("iteing"), dictgen::InsensitiveStr::Ascii("iten"), + dictgen::InsensitiveStr::Ascii("itet"), + dictgen::InsensitiveStr::Ascii("itewr"), + dictgen::InsensitiveStr::Ascii("itingm"), + dictgen::InsensitiveStr::Ascii("itter"), + dictgen::InsensitiveStr::Ascii("itters"), + dictgen::InsensitiveStr::Ascii("ittin"), dictgen::InsensitiveStr::Ascii("itting"), + dictgen::InsensitiveStr::Ascii("ittten"), + dictgen::InsensitiveStr::Ascii("kload"), + dictgen::InsensitiveStr::Ascii("kloads"), dictgen::InsensitiveStr::Ascii("nagler"), + dictgen::InsensitiveStr::Ascii("od"), dictgen::InsensitiveStr::Ascii("oet"), + dictgen::InsensitiveStr::Ascii("og"), dictgen::InsensitiveStr::Ascii("ok"), + dictgen::InsensitiveStr::Ascii("oked"), + dictgen::InsensitiveStr::Ascii("okflow"), + dictgen::InsensitiveStr::Ascii("okflows"), dictgen::InsensitiveStr::Ascii("oking"), + dictgen::InsensitiveStr::Ascii("okload"), + dictgen::InsensitiveStr::Ascii("okloads"), + dictgen::InsensitiveStr::Ascii("oks"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("onf"), + dictgen::InsensitiveStr::Ascii("ont"), dictgen::InsensitiveStr::Ascii("teched"), + dictgen::InsensitiveStr::Ascii("tie"), + dictgen::InsensitiveStr::Ascii("ting"), ], values: &[ + &["warning"], + &["warnings"], &["wrangler"], + &["wrapped", "warped"], + &["wrapped"], + &["wrapper"], + &["wrapping", "warping"], + &["wrap"], + &["wrapped"], + &["wrapping"], + &["wraps"], &["wrecking"], &["wretched"], &["wrecking"], @@ -327,110 +510,547 @@ pub static WORD_WR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["wrestlers"], &["wrestler"], &["write"], - &["written"], + &["writebuffer"], + &["writecheque"], &["writing"], + &["written"], + &["writes"], + &["writer"], + &["writing"], + &["writer"], + &["writers"], + &["written", "writing"], + &["writing"], + &["written"], + &["workload"], + &["workloads"], &["wrangler"], + &["word"], &["wrote"], + &["wrong"], &["work"], + &["worked"], + &["workflow"], + &["workflows"], &["working"], + &["workload"], + &["workloads"], + &["works"], + &["wrong"], + &["wrong"], + &["wrong"], &["wretched"], + &["write"], + &["writing"], ], - range: 2..=8, + range: 2..=10, }; -static WORD_WO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_WO_CHILDREN), +static WORD_WQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_WQ_CHILDREN), value: None, }; -pub static WORD_WO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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] = [ + None, + 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("hle"), - dictgen::InsensitiveStr::Ascii("kr"), - dictgen::InsensitiveStr::Ascii("kring"), - dictgen::InsensitiveStr::Ascii("lrdview"), - dictgen::InsensitiveStr::Ascii("lrdwide"), - dictgen::InsensitiveStr::Ascii("nderes"), - dictgen::InsensitiveStr::Ascii("nderfull"), - dictgen::InsensitiveStr::Ascii("nderfullly"), - dictgen::InsensitiveStr::Ascii("nderfuly"), - dictgen::InsensitiveStr::Ascii("nderlad"), - dictgen::InsensitiveStr::Ascii("nderus"), - dictgen::InsensitiveStr::Ascii("nderwand"), - dictgen::InsensitiveStr::Ascii("odowrking"), - dictgen::InsensitiveStr::Ascii("odworkign"), - dictgen::InsensitiveStr::Ascii("rdlview"), - dictgen::InsensitiveStr::Ascii("rdlwide"), - dictgen::InsensitiveStr::Ascii("rhsiping"), - dictgen::InsensitiveStr::Ascii("rhsipping"), - dictgen::InsensitiveStr::Ascii("rhtless"), - dictgen::InsensitiveStr::Ascii("rkfore"), - dictgen::InsensitiveStr::Ascii("rkfroce"), - dictgen::InsensitiveStr::Ascii("rkingest"), - dictgen::InsensitiveStr::Ascii("rkins"), - dictgen::InsensitiveStr::Ascii("rkstaion"), - dictgen::InsensitiveStr::Ascii("rkstaiton"), - dictgen::InsensitiveStr::Ascii("rkstaton"), - dictgen::InsensitiveStr::Ascii("rkststion"), - dictgen::InsensitiveStr::Ascii("rldivew"), - dictgen::InsensitiveStr::Ascii("rldveiw"), - dictgen::InsensitiveStr::Ascii("rls"), - dictgen::InsensitiveStr::Ascii("rshippig"), - dictgen::InsensitiveStr::Ascii("rshippping"), - dictgen::InsensitiveStr::Ascii("rshoping"), - dictgen::InsensitiveStr::Ascii("rshopping"), - dictgen::InsensitiveStr::Ascii("rstened"), - dictgen::InsensitiveStr::Ascii("rthelss"), - dictgen::InsensitiveStr::Ascii("udl"), - dictgen::InsensitiveStr::Ascii("udlnt"), - dictgen::InsensitiveStr::Ascii("udlve"), - dictgen::InsensitiveStr::Ascii("uldnot"), - dictgen::InsensitiveStr::Ascii("ulndt"), + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("dl"), + 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: &[ - &["whole"], - &["work"], - &["working"], - &["worldview"], - &["worldwide"], - &["wonders"], - &["wonderful"], - &["wonderfully"], - &["wonderfully"], - &["wonderland"], - &["wonders"], - &["wonderland"], - &["woodworking"], - &["woodworking"], - &["worldview"], - &["worldwide"], - &["worshiping"], - &["worshipping"], - &["worthless"], - &["workforce"], - &["workforce"], - &["workings"], - &["workings"], - &["workstation"], - &["workstation"], - &["workstation"], - &["workstation"], - &["worldview"], - &["worldview"], - &["world"], - &["worshipping"], - &["worshipping"], - &["worshiping"], - &["worshipping"], - &["worsened"], - &["worthless"], + &["would"], &["would"], &["wouldnt"], &["wouldve"], &["wouldnt"], &["wouldnt"], + &["wonderful"], + &["would"], + &["would"], ], - range: 2..=10, + 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"), + ], + values: &[&["worth"], &["without"]], + 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), + None, + 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, + None, + 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: None, +}; + +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_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: None, +}; + +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("aound"), + dictgen::InsensitiveStr::Ascii("aounds"), + dictgen::InsensitiveStr::Ascii("araound"), + dictgen::InsensitiveStr::Ascii("araounds"), + dictgen::InsensitiveStr::Ascii("arbound"), + dictgen::InsensitiveStr::Ascii("aroud"), + 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("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("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"), + ], + values: &[ + &["workaround"], + &["workaround"], + &["workarounds"], + &["workaround"], + &["workarounds"], + &["workaround"], + &["workaround"], + &["workarounds"], + &["workaround"], + &["workaround"], + &["workarounds"], + &["workaround"], + &["workarounds"], + &["workaround"], + &["workarounds"], + &["workbench"], + &["workbenches"], + &["workbenches"], + &["workbenches"], + &["workbench"], + &["workbenches"], + &["workbench"], + &["workbenches"], + &["workbooks"], + &["worked"], + &["work", "worked", "works"], + &["works"], + &["workforce"], + &["workflow"], + &["workflows"], + &["workforce"], + &["working"], + &["workings"], + &["workings"], + &["workflow"], + &["workflows"], + &["workspace"], + &["workspaces"], + &["workspace"], + &["workspaces"], + &["workstation"], + &["workstations"], + &["workstation"], + &["workstations"], + &["workstation"], + &["workstations"], + &["workstation"], + &["workstation"], + &["workstations"], + ], + 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("tless"), + ], + values: &[&["worshiping"], &["worshipping"], &["worthless"]], + range: 5..=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("lview"), + dictgen::InsensitiveStr::Ascii("lwide"), + dictgen::InsensitiveStr::Ascii("pres"), + ], + values: &[&["worldview"], &["worldwide"], &["wordpress"]], + range: 4..=5, +}; + +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("deres"), + dictgen::InsensitiveStr::Ascii("derfull"), + dictgen::InsensitiveStr::Ascii("derfullly"), + dictgen::InsensitiveStr::Ascii("derfuly"), + dictgen::InsensitiveStr::Ascii("derig"), + dictgen::InsensitiveStr::Ascii("derlad"), + dictgen::InsensitiveStr::Ascii("derus"), + dictgen::InsensitiveStr::Ascii("derwand"), + ], + values: &[ + &["wonders"], + &["wonderful"], + &["wonderfully"], + &["wonderfully"], + &["wondering"], + &["wonderland"], + &["wonders"], + &["wonderland"], + ], + range: 5..=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_WN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -442,10 +1062,22 @@ pub static WORD_WN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"], &["wanted"], &["wants"]], - range: 2..=4, + values: &[ + &["want", "what"], + &["wanted"], + &["wanting"], + &["wants"], + &["when", "wen"], + &["window", "widow"], + &["windows", "widows"], + ], + range: 2..=5, }; static WORD_WL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -454,9 +1086,23 @@ static WORD_WL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_WL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("acott")], - values: &[&["walcott"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("acott"), + dictgen::InsensitiveStr::Ascii("l"), + ], + values: &[&["walcott"], &["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 { @@ -473,14 +1119,14 @@ static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_WIG_NODE), Some(&WORD_WIH_NODE), - None, + Some(&WORD_WII_NODE), None, Some(&WORD_WIK_NODE), Some(&WORD_WIL_NODE), None, Some(&WORD_WIN_NODE), None, - None, + Some(&WORD_WIP_NODE), None, Some(&WORD_WIR_NODE), Some(&WORD_WIS_NODE), @@ -489,10 +1135,36 @@ static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, 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, @@ -511,6 +1183,10 @@ static WORD_WIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_WIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("able"), + dictgen::InsensitiveStr::Ascii("dh"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("ha"), dictgen::InsensitiveStr::Ascii("hces"), dictgen::InsensitiveStr::Ascii("hdral"), dictgen::InsensitiveStr::Ascii("hdrawalls"), @@ -527,18 +1203,50 @@ pub static WORD_WIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("hh"), dictgen::InsensitiveStr::Ascii("hhelding"), dictgen::InsensitiveStr::Ascii("hholdng"), + dictgen::InsensitiveStr::Ascii("hih"), dictgen::InsensitiveStr::Ascii("hing"), + dictgen::InsensitiveStr::Ascii("hinn"), + dictgen::InsensitiveStr::Ascii("hion"), + dictgen::InsensitiveStr::Ascii("ho"), + dictgen::InsensitiveStr::Ascii("hoit"), dictgen::InsensitiveStr::Ascii("hold"), + dictgen::InsensitiveStr::Ascii("holding"), + dictgen::InsensitiveStr::Ascii("hon"), + dictgen::InsensitiveStr::Ascii("hoout"), + dictgen::InsensitiveStr::Ascii("hot"), + dictgen::InsensitiveStr::Ascii("hotu"), + dictgen::InsensitiveStr::Ascii("hou"), + dictgen::InsensitiveStr::Ascii("houd"), + dictgen::InsensitiveStr::Ascii("houg"), + dictgen::InsensitiveStr::Ascii("hough"), + dictgen::InsensitiveStr::Ascii("hought"), + dictgen::InsensitiveStr::Ascii("houht"), + dictgen::InsensitiveStr::Ascii("hount"), + dictgen::InsensitiveStr::Ascii("hour"), + dictgen::InsensitiveStr::Ascii("hourt"), + dictgen::InsensitiveStr::Ascii("hous"), + dictgen::InsensitiveStr::Ascii("houth"), + dictgen::InsensitiveStr::Ascii("houyt"), + dictgen::InsensitiveStr::Ascii("hput"), dictgen::InsensitiveStr::Ascii("hrdawal"), dictgen::InsensitiveStr::Ascii("hrdawing"), + dictgen::InsensitiveStr::Ascii("hs"), dictgen::InsensitiveStr::Ascii("ht"), + dictgen::InsensitiveStr::Ascii("in"), + dictgen::InsensitiveStr::Ascii("k"), dictgen::InsensitiveStr::Ascii("n"), dictgen::InsensitiveStr::Ascii("nesess"), dictgen::InsensitiveStr::Ascii("nesss"), dictgen::InsensitiveStr::Ascii("nesssing"), dictgen::InsensitiveStr::Ascii("nissing"), + dictgen::InsensitiveStr::Ascii("out"), + dictgen::InsensitiveStr::Ascii("th"), ], values: &[ + &["writeable"], + &["width"], + &["write", "white"], + &["with"], &["witches"], &["withdrawal"], &["withdrawals"], @@ -546,7 +1254,7 @@ pub static WORD_WIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["withdrawal"], &["withdrawals"], &["withdrawn"], - &["withdrawal"], + &["withdrawal", "withdraw"], &["withdrawals"], &["withdrawing"], &["withdrawing"], @@ -556,15 +1264,43 @@ pub static WORD_WIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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"], &["withdrawals"], &["withdrawing"], + &["with", "widths"], + &["with"], + &["within"], &["with"], &["with"], &["witnesses"], &["witnesses"], &["witnessing"], &["witnessing"], + &["without"], + &["with"], ], range: 1..=9, }; @@ -605,11 +1341,45 @@ static WORD_WIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_WIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ded"), dictgen::InsensitiveStr::Ascii("edest"), + 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: &[&["weirdest"], &["writing"]], - range: 4..=5, + values: &[ + &["wired", "weird"], + &["weirdest"], + &["with"], + &["writable", "writeable"], + &["write"], + &["writer"], + &["writers"], + &["writes"], + &["with", "worth"], + &["writing"], + &["written"], + &["virtual"], + ], + range: 1..=5, +}; + +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 { @@ -622,16 +1392,26 @@ pub static WORD_WIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("dsheild"), dictgen::InsensitiveStr::Ascii("dsheilds"), dictgen::InsensitiveStr::Ascii("dshied"), dictgen::InsensitiveStr::Ascii("dshiled"), dictgen::InsensitiveStr::Ascii("dsoar"), + dictgen::InsensitiveStr::Ascii("dwo"), 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"), @@ -640,32 +1420,45 @@ pub static WORD_WIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["winchester"], &["winchester"], &["windshield"], + &["window"], + &["windows"], + &["window"], + &["windows"], + &["windows"], &["windsor"], &["windshield"], &["windshield"], &["windshield"], &["windshield"], &["windsor"], + &["window"], &["winnipeg"], + &["win"], + &["window"], + &["windows"], &["winnings"], &["winnings"], &["winnipeg"], + &["window"], &["windsor"], &["witnesses"], &["winston"], ], - range: 4..=8, + range: 1..=8, }; static WORD_WIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_WIL_CHILDREN), - value: None, + 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("derniss"), dictgen::InsensitiveStr::Ascii("dreness"), + dictgen::InsensitiveStr::Ascii("h"), dictgen::InsensitiveStr::Ascii("laims"), dictgen::InsensitiveStr::Ascii("le"), dictgen::InsensitiveStr::Ascii("lfullly"), @@ -673,10 +1466,14 @@ pub static WORD_WIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("limas"), dictgen::InsensitiveStr::Ascii("lingless"), dictgen::InsensitiveStr::Ascii("lk"), + dictgen::InsensitiveStr::Ascii("ll"), ], values: &[ + &["wildcard"], + &["wildcards"], &["wilderness"], &["wilderness"], + &["will"], &["williams"], &["will"], &["willfully"], @@ -684,8 +1481,9 @@ pub static WORD_WIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["williams"], &["willingness"], &["will"], + &["will"], ], - range: 2..=8, + range: 1..=8, }; static WORD_WIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -697,9 +1495,21 @@ pub static WORD_WIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("ileakers"), dictgen::InsensitiveStr::Ascii("ileakes"), + dictgen::InsensitiveStr::Ascii("pedia"), ], - values: &[&["wikileaks"], &["wikileaks"]], - range: 7..=8, + 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 { @@ -708,9 +1518,27 @@ static WORD_WIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_WIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("t")], - values: &[&["with"]], - range: 1..=1, + 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 { @@ -719,9 +1547,19 @@ static WORD_WIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_WIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("dets")], - values: &[&["widgets"]], - range: 4..=4, + 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 { @@ -732,18 +1570,30 @@ static WORD_WIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], - &["weighted"], + &["weighed"], + &["weight"], + &["weighted", "weighed"], &["weightlifting"], &["weights"], + &["view"], &["weird"], + &["weirdly"], + &["weirdness"], + &["width"], &["view"], ], range: 1..=10, @@ -759,17 +1609,31 @@ pub static WORD_WID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("epsread"), dictgen::InsensitiveStr::Ascii("espred"), dictgen::InsensitiveStr::Ascii("esread"), + dictgen::InsensitiveStr::Ascii("ged"), dictgen::InsensitiveStr::Ascii("gest"), dictgen::InsensitiveStr::Ascii("getas"), + dictgen::InsensitiveStr::Ascii("git"), + dictgen::InsensitiveStr::Ascii("ht"), + dictgen::InsensitiveStr::Ascii("htpoint"), + dictgen::InsensitiveStr::Ascii("htpoints"), + dictgen::InsensitiveStr::Ascii("thn"), + dictgen::InsensitiveStr::Ascii("thout"), ], values: &[ &["widespread"], &["widespread"], &["widespread"], + &["widget"], &["widgets"], &["widgets"], + &["widget"], + &["width"], + &["widthpoint"], + &["widthpoints"], + &["width"], + &["without"], ], - range: 4..=7, + range: 2..=8, }; static WORD_WIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -778,8 +1642,11 @@ static WORD_WIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_WIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("h")], - values: &[&["which"]], + keys: &[ + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("h"), + ], + values: &[&["vice"], &["which"]], range: 1..=1, }; @@ -790,93 +1657,249 @@ static WORD_WIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["waiters"], &["waivers"]], - range: 4..=4, + values: &[&["wait"], &["waiters"], &["waivers"]], + range: 1..=4, }; static WORD_WH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_WH_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_WH_CHILDREN), value: None, }; -pub static WORD_WH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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("aeton"), - dictgen::InsensitiveStr::Ascii("ant"), - dictgen::InsensitiveStr::Ascii("ants"), - dictgen::InsensitiveStr::Ascii("atosever"), - dictgen::InsensitiveStr::Ascii("atseover"), - dictgen::InsensitiveStr::Ascii("cih"), - dictgen::InsensitiveStr::Ascii("eras"), - dictgen::InsensitiveStr::Ascii("erease"), - dictgen::InsensitiveStr::Ascii("ereever"), - dictgen::InsensitiveStr::Ascii("eter"), - dictgen::InsensitiveStr::Ascii("ic"), - dictgen::InsensitiveStr::Ascii("ietlist"), - dictgen::InsensitiveStr::Ascii("ihc"), - dictgen::InsensitiveStr::Ascii("ilrwind"), - dictgen::InsensitiveStr::Ascii("ilsting"), - dictgen::InsensitiveStr::Ascii("ipser"), - dictgen::InsensitiveStr::Ascii("ipsered"), - dictgen::InsensitiveStr::Ascii("ipsering"), - dictgen::InsensitiveStr::Ascii("ipsers"), - dictgen::InsensitiveStr::Ascii("islist"), - dictgen::InsensitiveStr::Ascii("islte"), - dictgen::InsensitiveStr::Ascii("isltes"), - dictgen::InsensitiveStr::Ascii("islting"), - dictgen::InsensitiveStr::Ascii("isperd"), - dictgen::InsensitiveStr::Ascii("isperered"), - dictgen::InsensitiveStr::Ascii("isperes"), - dictgen::InsensitiveStr::Ascii("istel"), - dictgen::InsensitiveStr::Ascii("istels"), - dictgen::InsensitiveStr::Ascii("itelsit"), - dictgen::InsensitiveStr::Ascii("ith"), - dictgen::InsensitiveStr::Ascii("itholding"), - dictgen::InsensitiveStr::Ascii("itleist"), - dictgen::InsensitiveStr::Ascii("itsle"), - dictgen::InsensitiveStr::Ascii("itsles"), - dictgen::InsensitiveStr::Ascii("itsling"), - dictgen::InsensitiveStr::Ascii("lch"), - dictgen::InsensitiveStr::Ascii("n"), - dictgen::InsensitiveStr::Ascii("oleheartadly"), - dictgen::InsensitiveStr::Ascii("oleheartdly"), - dictgen::InsensitiveStr::Ascii("oleheartedy"), - dictgen::InsensitiveStr::Ascii("oleheartely"), - dictgen::InsensitiveStr::Ascii("oleheartidly"), - dictgen::InsensitiveStr::Ascii("oley"), - dictgen::InsensitiveStr::Ascii("oly"), - dictgen::InsensitiveStr::Ascii("rilwind"), - dictgen::InsensitiveStr::Ascii("siper"), - dictgen::InsensitiveStr::Ascii("sipered"), - dictgen::InsensitiveStr::Ascii("sipering"), - dictgen::InsensitiveStr::Ascii("sipers"), - dictgen::InsensitiveStr::Ascii("ta"), - dictgen::InsensitiveStr::Ascii("ther"), - dictgen::InsensitiveStr::Ascii("tielist"), + dictgen::InsensitiveStr::Ascii("th"), + dictgen::InsensitiveStr::Ascii("thout"), + ], + values: &[&["with"], &["without"]], + range: 2..=5, +}; + +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("ilwind")], + values: &[&["whirlwind"]], + range: 6..=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("ley"), + dictgen::InsensitiveStr::Ascii("ly"), + dictgen::InsensitiveStr::Ascii("ose"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("uld"), + ], + values: &[ + &["whose"], + &["wholeheartedly"], + &["wholeheartedly"], + &["wholeheartedly"], + &["wholeheartedly"], + &["wholeheartedly"], + &["wholly"], + &["wholly", "holy"], + &["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("hc"), + dictgen::InsensitiveStr::Ascii("hch"), + dictgen::InsensitiveStr::Ascii("ke"), + dictgen::InsensitiveStr::Ascii("lest"), + 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"), ], values: &[ - &["wheaton"], - &["want"], - &["wants"], - &["whatsoever"], - &["whatsoever"], &["which"], - &["whereas"], - &["whereas"], - &["wherever"], - &["whether"], + &["which"], &["which"], &["whitelist"], &["which"], + &["which"], + &["while"], + &["whilst"], &["whirlwind"], &["whistling"], + &["whitelist"], + &["whitelisted"], + &["whitelisting"], + &["whitelists"], + &["while"], + &["which"], + &["whipped", "wiped"], &["whisper"], &["whispered"], &["whispering"], &["whispers"], + &["this", "whisk"], + &["wish", "whisk"], + &["wishlist"], &["wishlist"], &["whistle"], &["whistles"], @@ -886,32 +1909,130 @@ pub static WORD_WH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["whispers"], &["whistle"], &["whistles"], + &["which"], + &["whichever"], &["whitelist"], + &["whitespace"], + &["whitespaces"], &["with"], + &["with", "white"], + &["within"], &["withholding"], + &["without"], &["whitelist"], + &["without", "whiteout"], + &["white"], &["whistle"], &["whistles"], &["whistling"], - &["which"], - &["when"], - &["wholeheartedly"], - &["wholeheartedly"], - &["wholeheartedly"], - &["wholeheartedly"], - &["wholeheartedly"], - &["wholly"], - &["wholly"], - &["whirlwind"], - &["whisper"], - &["whispered"], - &["whispering"], - &["whispers"], - &["what"], - &["whether"], - &["whitelist"], + &["whitespace"], ], - range: 1..=12, + 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")], + values: &[&["wheel"]], + range: 3..=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("hter"), + dictgen::InsensitiveStr::Ascii("igh"), + dictgen::InsensitiveStr::Ascii("ll"), + dictgen::InsensitiveStr::Ascii("nevery"), + 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"), + ], + values: &[ + &["weather", "whether"], + &["whether"], + &["weigh"], + &["wheel", "well"], + &["whenever"], + &["whenever"], + &["where"], + &["whereas"], + &["whereas"], + &["wherever"], + &["whether"], + &["where"], + &["whether"], + &["whether"], + &["whether"], + &["whether"], + &["whether"], + ], + 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("ih"), + ], + values: &[&["which"], &["which"]], + range: 1..=2, +}; + +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("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("tosever"), + dictgen::InsensitiveStr::Ascii("tseover"), + ], + values: &[ + &["wheaton"], + &["want", "when"], + &["want"], + &["wants"], + &["whatever"], + &["whitespace"], + &["whitespaces"], + &["whether", "weather"], + &["whatsoever"], + &["whatsoever"], + ], + range: 1..=8, }; static WORD_WE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -926,7 +2047,7 @@ static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_WED_NODE), None, None, - None, + Some(&WORD_WEG_NODE), Some(&WORD_WEH_NODE), Some(&WORD_WEI_NODE), None, @@ -939,15 +2060,37 @@ static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_WER_NODE), Some(&WORD_WES_NODE), + Some(&WORD_WET_NODE), None, None, - None, - None, + Some(&WORD_WEW_NODE), None, None, None, ]; +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, @@ -1001,21 +2144,29 @@ static WORD_WER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 4..=7, + range: 1..=7, }; static WORD_WEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -1089,13 +2240,17 @@ pub static WORD_WEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], values: &[ &["weighted"], @@ -1103,13 +2258,17 @@ pub static WORD_WEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["weightlifting"], &["weightlifting"], &["weightlifting"], + &["weight"], &["weighted"], &["weightlifting"], &["weights"], - &["wield"], + &["wield", "wild"], &["wielded"], + &["will"], + &["weird"], &["weirdly"], &["weirdos"], + &["weight"], ], range: 2..=10, }; @@ -1120,8 +2279,23 @@ static WORD_WEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_WEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("n")], - values: &[&["when"]], + 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, }; @@ -1134,6 +2308,7 @@ pub static WORD_WED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("ensday"), dictgen::InsensitiveStr::Ascii("ensdays"), + dictgen::InsensitiveStr::Ascii("nesdaay"), dictgen::InsensitiveStr::Ascii("nesdsay"), dictgen::InsensitiveStr::Ascii("nesdsy"), dictgen::InsensitiveStr::Ascii("nesdy"), @@ -1145,6 +2320,7 @@ pub static WORD_WED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["wednesday"], &["wednesdays"], + &["wednesday"], &["wednesdays"], &["wednesdays"], &["wednesdays"], @@ -1194,6 +2370,7 @@ pub static WORD_WEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("knessses"), dictgen::InsensitiveStr::Ascii("ltheir"), dictgen::InsensitiveStr::Ascii("lthly"), + dictgen::InsensitiveStr::Ascii("nt"), dictgen::InsensitiveStr::Ascii("ponary"), dictgen::InsensitiveStr::Ascii("s"), dictgen::InsensitiveStr::Ascii("thliest"), @@ -1207,6 +2384,7 @@ pub static WORD_WEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["weaknesses"], &["wealthier"], &["wealthy"], + &["want", "wean"], &["weaponry"], &["was"], &["wealthiest"], @@ -1215,82 +2393,259 @@ pub static WORD_WEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_WA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_WA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_WA_CHILDREN), value: None, }; -pub static WORD_WA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("word")], + values: &[&["wayward"]], + range: 4..=4, +}; + +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("rick")], + values: &[&["warwick"]], + range: 4..=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("clott"), - dictgen::InsensitiveStr::Ascii("cther"), - dictgen::InsensitiveStr::Ascii("ht"), - dictgen::InsensitiveStr::Ascii("htever"), - dictgen::InsensitiveStr::Ascii("itres"), - dictgen::InsensitiveStr::Ascii("ktins"), - dictgen::InsensitiveStr::Ascii("llpapaers"), - dictgen::InsensitiveStr::Ascii("llpapes"), - dictgen::InsensitiveStr::Ascii("llpappers"), - dictgen::InsensitiveStr::Ascii("llpapr"), - dictgen::InsensitiveStr::Ascii("rantee"), - dictgen::InsensitiveStr::Ascii("rcarft"), - dictgen::InsensitiveStr::Ascii("rcrat"), - dictgen::InsensitiveStr::Ascii("rdobe"), - dictgen::InsensitiveStr::Ascii("riwck"), - dictgen::InsensitiveStr::Ascii("rrandyte"), - dictgen::InsensitiveStr::Ascii("rrante"), - dictgen::InsensitiveStr::Ascii("rrantles"), - dictgen::InsensitiveStr::Ascii("rrantly"), - dictgen::InsensitiveStr::Ascii("rrany"), - dictgen::InsensitiveStr::Ascii("rrent"), - dictgen::InsensitiveStr::Ascii("rrenties"), - dictgen::InsensitiveStr::Ascii("rrios"), - dictgen::InsensitiveStr::Ascii("rriros"), - dictgen::InsensitiveStr::Ascii("rrriors"), - dictgen::InsensitiveStr::Ascii("rwcik"), - dictgen::InsensitiveStr::Ascii("shignton"), - dictgen::InsensitiveStr::Ascii("shingtion"), - dictgen::InsensitiveStr::Ascii("ss"), - dictgen::InsensitiveStr::Ascii("tchemn"), - dictgen::InsensitiveStr::Ascii("tchign"), - dictgen::InsensitiveStr::Ascii("terlemon"), - dictgen::InsensitiveStr::Ascii("termalon"), - dictgen::InsensitiveStr::Ascii("termeleon"), - dictgen::InsensitiveStr::Ascii("terproff"), - dictgen::InsensitiveStr::Ascii("terprooof"), - dictgen::InsensitiveStr::Ascii("thcer"), - dictgen::InsensitiveStr::Ascii("thcing"), - dictgen::InsensitiveStr::Ascii("thcmen"), - dictgen::InsensitiveStr::Ascii("thever"), - dictgen::InsensitiveStr::Ascii("tiers"), - dictgen::InsensitiveStr::Ascii("tkings"), - dictgen::InsensitiveStr::Ascii("tn"), - dictgen::InsensitiveStr::Ascii("velegnth"), - dictgen::InsensitiveStr::Ascii("velegnths"), - dictgen::InsensitiveStr::Ascii("velengh"), - dictgen::InsensitiveStr::Ascii("velenghs"), - dictgen::InsensitiveStr::Ascii("velenght"), - dictgen::InsensitiveStr::Ascii("velenghth"), - dictgen::InsensitiveStr::Ascii("velenghts"), - dictgen::InsensitiveStr::Ascii("viers"), - dictgen::InsensitiveStr::Ascii("wrick"), - dictgen::InsensitiveStr::Ascii("yword"), + 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("iers"), ], values: &[ - &["walcott"], + &["wavelength"], + &["wavelength"], + &["wavelength"], + &["wavelength"], + &["wavelength"], + &["wavelength"], + &["wavelength", "wavelengths"], + &["wavelines"], + &["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"], - &["what"], + &["watching"], + &["watchmen"], + &["watchdog"], &["whatever"], + &["whats", "watches"], &["waiters"], + &["waiting"], &["watkins"], - &["wallpapers"], - &["wallpapers"], - &["wallpapers"], - &["wallpapers"], + &["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("n"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[&["washington"], &["washington"], &["was"], &["was"]], + range: 1..=8, +}; + +static WORD_WAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_WAR_CHILDREN), + value: None, +}; + +pub static WORD_WAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("antee"), + dictgen::InsensitiveStr::Ascii("anties"), + dictgen::InsensitiveStr::Ascii("anty"), + dictgen::InsensitiveStr::Ascii("carft"), + dictgen::InsensitiveStr::Ascii("crat"), + dictgen::InsensitiveStr::Ascii("dobe"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("inigs"), + dictgen::InsensitiveStr::Ascii("inings"), + dictgen::InsensitiveStr::Ascii("iwck"), + dictgen::InsensitiveStr::Ascii("ks"), + dictgen::InsensitiveStr::Ascii("lking"), + dictgen::InsensitiveStr::Ascii("nibg"), + dictgen::InsensitiveStr::Ascii("nibgs"), + dictgen::InsensitiveStr::Ascii("nig"), + dictgen::InsensitiveStr::Ascii("nign"), + dictgen::InsensitiveStr::Ascii("nigns"), + dictgen::InsensitiveStr::Ascii("nigs"), + dictgen::InsensitiveStr::Ascii("niing"), + dictgen::InsensitiveStr::Ascii("niings"), + dictgen::InsensitiveStr::Ascii("nin"), + dictgen::InsensitiveStr::Ascii("nind"), + dictgen::InsensitiveStr::Ascii("ninds"), + dictgen::InsensitiveStr::Ascii("ninf"), + dictgen::InsensitiveStr::Ascii("ninfs"), + dictgen::InsensitiveStr::Ascii("ningss"), + dictgen::InsensitiveStr::Ascii("ninig"), + dictgen::InsensitiveStr::Ascii("ninigs"), + dictgen::InsensitiveStr::Ascii("nining"), + dictgen::InsensitiveStr::Ascii("ninings"), + dictgen::InsensitiveStr::Ascii("ninng"), + dictgen::InsensitiveStr::Ascii("ninngs"), + dictgen::InsensitiveStr::Ascii("nins"), + dictgen::InsensitiveStr::Ascii("ninsg"), + dictgen::InsensitiveStr::Ascii("ninsgs"), + dictgen::InsensitiveStr::Ascii("niong"), + dictgen::InsensitiveStr::Ascii("niongs"), + dictgen::InsensitiveStr::Ascii("randyte"), + dictgen::InsensitiveStr::Ascii("rante"), + dictgen::InsensitiveStr::Ascii("rantles"), + dictgen::InsensitiveStr::Ascii("rantly"), + dictgen::InsensitiveStr::Ascii("rany"), + dictgen::InsensitiveStr::Ascii("rent"), + dictgen::InsensitiveStr::Ascii("renties"), + dictgen::InsensitiveStr::Ascii("rios"), + dictgen::InsensitiveStr::Ascii("riros"), + dictgen::InsensitiveStr::Ascii("rriors"), + dictgen::InsensitiveStr::Ascii("wcik"), + ], + values: &[ + &["warranty"], + &["warranties"], &["warranty"], &["warcraft"], &["warcraft"], &["wardrobe"], + &["warning"], + &["warnings"], + &["warnings"], &["warwick"], + &["works"], + &["walking"], + &["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"], &["warranty"], &["warranties"], &["warranties"], @@ -1302,35 +2657,94 @@ pub static WORD_WA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["warriors"], &["warriors"], &["warwick"], - &["washington"], - &["washington"], - &["was"], - &["watchmen"], - &["watching"], - &["watermelon"], - &["watermelon"], - &["watermelon"], - &["waterproof"], - &["waterproof"], - &["watcher"], - &["watching"], - &["watchmen"], - &["whatever"], - &["waiters"], - &["watkins"], - &["want"], - &["wavelength"], - &["wavelength"], - &["wavelength"], - &["wavelength"], - &["wavelength"], - &["wavelength"], - &["wavelength"], - &["waivers"], - &["warwick"], - &["wayward"], ], - range: 2..=9, + range: 2..=7, +}; + +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("tres")], + values: &[&["waiters"]], + range: 4..=4, +}; + +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 { @@ -1340,17 +2754,17 @@ static WORD_V_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_V_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_VA_NODE), - None, + Some(&WORD_VB_NODE), None, None, Some(&WORD_VE_NODE), None, None, - None, + Some(&WORD_VH_NODE), Some(&WORD_VI_NODE), None, None, - None, + Some(&WORD_VL_NODE), None, None, Some(&WORD_VO_NODE), @@ -1382,37 +2796,176 @@ pub static WORD_VY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg }; static WORD_VU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_VU_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_VU_CHILDREN), value: None, }; -pub static WORD_VU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("lberability"), - dictgen::InsensitiveStr::Ascii("lernabilities"), - dictgen::InsensitiveStr::Ascii("lernability"), - dictgen::InsensitiveStr::Ascii("lernable"), - dictgen::InsensitiveStr::Ascii("lnarabilities"), - dictgen::InsensitiveStr::Ascii("lnarability"), - dictgen::InsensitiveStr::Ascii("lnarable"), - dictgen::InsensitiveStr::Ascii("lnerabil"), - dictgen::InsensitiveStr::Ascii("lnerabile"), - dictgen::InsensitiveStr::Ascii("lnerabilites"), - dictgen::InsensitiveStr::Ascii("lnerabillity"), - dictgen::InsensitiveStr::Ascii("lnerabiltiy"), - dictgen::InsensitiveStr::Ascii("lnerabilty"), - dictgen::InsensitiveStr::Ascii("lnerablility"), - dictgen::InsensitiveStr::Ascii("lnurabilities"), - dictgen::InsensitiveStr::Ascii("lnurability"), - dictgen::InsensitiveStr::Ascii("lnurable"), - dictgen::InsensitiveStr::Ascii("nlerabilities"), - dictgen::InsensitiveStr::Ascii("nlerability"), - dictgen::InsensitiveStr::Ascii("nlerable"), - dictgen::InsensitiveStr::Ascii("rnerabilities"), - dictgen::InsensitiveStr::Ascii("rnerability"), + 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("erable"), + dictgen::InsensitiveStr::Ascii("lerabilities"), + dictgen::InsensitiveStr::Ascii("lerability"), + dictgen::InsensitiveStr::Ascii("lerable"), ], values: &[ + &["vulnerable"], + &["vulnerabilities"], &["vulnerability"], + &["vulnerable"], + ], + range: 6..=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::Flat(&WORD_VULN_CHILDREN), + value: None, +}; + +pub static WORD_VULN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("arabilities"), + dictgen::InsensitiveStr::Ascii("arability"), + dictgen::InsensitiveStr::Ascii("arable"), + dictgen::InsensitiveStr::Ascii("eabilities"), + dictgen::InsensitiveStr::Ascii("eability"), + dictgen::InsensitiveStr::Ascii("eable"), + dictgen::InsensitiveStr::Ascii("earabilities"), + dictgen::InsensitiveStr::Ascii("earability"), + 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("erabil"), + dictgen::InsensitiveStr::Ascii("erabile"), + 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("erabilitu"), + dictgen::InsensitiveStr::Ascii("erabiliy"), + dictgen::InsensitiveStr::Ascii("erabillities"), + dictgen::InsensitiveStr::Ascii("erabillity"), + dictgen::InsensitiveStr::Ascii("erabilties"), + dictgen::InsensitiveStr::Ascii("erabiltiy"), + dictgen::InsensitiveStr::Ascii("erabilty"), + dictgen::InsensitiveStr::Ascii("erablility"), + dictgen::InsensitiveStr::Ascii("erablities"), + dictgen::InsensitiveStr::Ascii("erablity"), + 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("erarbilities"), + dictgen::InsensitiveStr::Ascii("erarbility"), + dictgen::InsensitiveStr::Ascii("erarble"), + dictgen::InsensitiveStr::Ascii("erbilities"), + dictgen::InsensitiveStr::Ascii("erbility"), + dictgen::InsensitiveStr::Ascii("erbuilities"), + dictgen::InsensitiveStr::Ascii("erbuility"), + dictgen::InsensitiveStr::Ascii("urabilities"), + dictgen::InsensitiveStr::Ascii("urability"), + dictgen::InsensitiveStr::Ascii("urable"), + ], + values: &[ + &["vulnerabilities"], + &["vulnerability"], + &["vulnerable"], &["vulnerabilities"], &["vulnerability"], &["vulnerable"], @@ -1420,22 +2973,184 @@ pub static WORD_VU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["vulnerability"], &["vulnerable"], &["vulnerable"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], &["vulnerable"], + &["vulnerable"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerability"], &["vulnerabilities"], &["vulnerability"], &["vulnerability"], &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerability"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerable"], &["vulnerability"], &["vulnerabilities"], &["vulnerability"], &["vulnerable"], &["vulnerabilities"], &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], + &["vulnerabilities"], + &["vulnerability"], &["vulnerable"], + ], + range: 5..=13, +}; + +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: 8..=13, + 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 { @@ -1446,21 +3161,51 @@ static WORD_VR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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"], + &["verifies"], + &["verify"], &["virginity"], &["virgins"], + &["verilog"], + &["virtual"], + &["virtualenv"], + &["virtualisation"], + &["virtualise"], + &["virtualization"], + &["virtualize"], + &["virtuoso"], + &["version"], + &["versions"], ], - range: 2..=7, + range: 2..=12, }; static WORD_VO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -1480,7 +3225,10 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ilating"), dictgen::InsensitiveStr::Ascii("ilation"), dictgen::InsensitiveStr::Ascii("ilently"), + dictgen::InsensitiveStr::Ascii("latage"), + dictgen::InsensitiveStr::Ascii("latages"), dictgen::InsensitiveStr::Ascii("latge"), + dictgen::InsensitiveStr::Ascii("latges"), dictgen::InsensitiveStr::Ascii("latiliy"), dictgen::InsensitiveStr::Ascii("latillity"), dictgen::InsensitiveStr::Ascii("latiltiy"), @@ -1489,6 +3237,9 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("lcando"), dictgen::InsensitiveStr::Ascii("lcanoe"), dictgen::InsensitiveStr::Ascii("lcaron"), + dictgen::InsensitiveStr::Ascii("lenteer"), + dictgen::InsensitiveStr::Ascii("lenteered"), + dictgen::InsensitiveStr::Ascii("lenteers"), dictgen::InsensitiveStr::Ascii("leyball"), dictgen::InsensitiveStr::Ascii("litality"), dictgen::InsensitiveStr::Ascii("lleyboll"), @@ -1503,6 +3254,7 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("lounteering"), dictgen::InsensitiveStr::Ascii("lounteers"), dictgen::InsensitiveStr::Ascii("lumne"), + dictgen::InsensitiveStr::Ascii("lums"), dictgen::InsensitiveStr::Ascii("lunatrily"), dictgen::InsensitiveStr::Ascii("lunatry"), dictgen::InsensitiveStr::Ascii("luntairly"), @@ -1519,7 +3271,10 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("luntereed"), dictgen::InsensitiveStr::Ascii("lunterily"), dictgen::InsensitiveStr::Ascii("lunterring"), + dictgen::InsensitiveStr::Ascii("nfig"), dictgen::InsensitiveStr::Ascii("tlage"), + dictgen::InsensitiveStr::Ascii("uld"), + dictgen::InsensitiveStr::Ascii("xes"), ], values: &[ &["vocabulary"], @@ -1533,6 +3288,9 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["violation"], &["violently"], &["voltage"], + &["voltages"], + &["voltage"], + &["voltages"], &["volatility"], &["volatility"], &["volatility"], @@ -1541,6 +3299,9 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["volcano"], &["volcano"], &["volcano"], + &["volunteer"], + &["volunteered"], + &["volunteers"], &["volleyball"], &["volatility"], &["volleyball"], @@ -1555,6 +3316,7 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["volunteering"], &["volunteers"], &["volume"], + &["volume"], &["voluntarily"], &["voluntary"], &["voluntarily"], @@ -1571,9 +3333,39 @@ pub static WORD_VO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["volunteered"], &["voluntarily"], &["volunteering"], + &["config"], &["voltage"], + &["would"], + &["voxels", "voxel"], ], - range: 5..=11, + range: 3..=11, +}; + +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 { @@ -1602,9 +3394,9 @@ static WORD_VI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_VIR_NODE), Some(&WORD_VIS_NODE), Some(&WORD_VIT_NODE), + Some(&WORD_VIU_NODE), None, - None, - None, + Some(&WORD_VIW_NODE), None, None, Some(&WORD_VIZ_NODE), @@ -1617,11 +3409,52 @@ static WORD_VIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["visualization"]], - range: 10..=11, + values: &[ + &["visualisation"], + &["visualisation"], + &["visualise"], + &["visualised"], + &["visualization"], + &["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("er"), + dictgen::InsensitiveStr::Ascii("ers"), + ], + values: &[&["viewer"], &["viewers"]], + range: 2..=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 { @@ -1647,6 +3480,7 @@ pub static WORD_VIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rual"), dictgen::InsensitiveStr::Ascii("rually"), dictgen::InsensitiveStr::Ascii("rues"), + dictgen::InsensitiveStr::Ascii("ual"), dictgen::InsensitiveStr::Ascii("ualization"), ], values: &[ @@ -1666,56 +3500,257 @@ pub static WORD_VIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["virtual"], &["virtually"], &["virtues"], + &["virtual"], &["visualization"], ], - range: 4..=10, + range: 3..=10, }; static WORD_VIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_VIS_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_VIS_CHILDREN), value: None, }; -pub static WORD_VIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("alizaiton"), + dictgen::InsensitiveStr::Ascii("alizating"), + dictgen::InsensitiveStr::Ascii("alizaton"), + dictgen::InsensitiveStr::Ascii("allisation"), + dictgen::InsensitiveStr::Ascii("allization"), + dictgen::InsensitiveStr::Ascii("aly"), + dictgen::InsensitiveStr::Ascii("alyse"), + ], + 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"], + &["visualization"], + &["visualisation"], + &["visualization"], + &["visually"], + &["visualise", "visualise"], + ], + range: 2..=10, +}; + +static WORD_VIST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_VIST_CHILDREN), + value: None, +}; + +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"), + ], + values: &[&["visited"], &["visiting"], &["visitors"]], + range: 2..=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("bile"), + dictgen::InsensitiveStr::Ascii("biliy"), + dictgen::InsensitiveStr::Ascii("billity"), + dictgen::InsensitiveStr::Ascii("biltiy"), + dictgen::InsensitiveStr::Ascii("bilty"), dictgen::InsensitiveStr::Ascii("bily"), - dictgen::InsensitiveStr::Ascii("creal"), - dictgen::InsensitiveStr::Ascii("ercal"), - dictgen::InsensitiveStr::Ascii("ibiliy"), - dictgen::InsensitiveStr::Ascii("ibillity"), - dictgen::InsensitiveStr::Ascii("ibiltiy"), - dictgen::InsensitiveStr::Ascii("ibily"), - dictgen::InsensitiveStr::Ascii("ibley"), - dictgen::InsensitiveStr::Ascii("iblly"), - dictgen::InsensitiveStr::Ascii("ting"), - dictgen::InsensitiveStr::Ascii("tors"), - dictgen::InsensitiveStr::Ascii("ualizacion"), - dictgen::InsensitiveStr::Ascii("ualizaiton"), - dictgen::InsensitiveStr::Ascii("ualizating"), - dictgen::InsensitiveStr::Ascii("ualizaton"), + 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("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"], + &["visible"], + &["visibility"], + &["visibility"], + &["visibility"], + &["visibility"], + &["visibility"], + &["visible"], + &["visible"], &["visibly"], - &["visceral"], - &["visceral"], - &["visibility"], - &["visibility"], - &["visibility"], + &["visibilities"], &["visibility"], + &["visible"], &["visibly"], - &["visibly"], - &["visiting"], + &["visible"], + &["vicious"], + &["visible"], + &["visitor"], &["visitors"], - &["visualization"], - &["visualization"], - &["visualization"], - &["visualization"], + &["visiting"], + &["visible"], ], - range: 4..=10, + range: 3..=7, +}; + +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("rcal")], + values: &[&["visceral"]], + range: 4..=4, +}; + +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("ily"), + dictgen::InsensitiveStr::Ascii("le"), + dictgen::InsensitiveStr::Ascii("lie"), + dictgen::InsensitiveStr::Ascii("ly"), + ], + values: &[&["visibly"], &["visible"], &["visible"], &["visibly"]], + range: 2..=3, +}; + +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 { @@ -1737,13 +3772,34 @@ pub static WORD_VIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ginus"), dictgen::InsensitiveStr::Ascii("ignity"), dictgen::InsensitiveStr::Ascii("igns"), + dictgen::InsensitiveStr::Ascii("tal"), + dictgen::InsensitiveStr::Ascii("taul"), + dictgen::InsensitiveStr::Ascii("tical"), dictgen::InsensitiveStr::Ascii("tiol"), + dictgen::InsensitiveStr::Ascii("tiual"), + 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("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"), ], values: &[ @@ -1759,16 +3815,37 @@ pub static WORD_VIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["virgins"], &["virginity"], &["virgins"], + &["virtual"], + &["virtual"], + &["vertical"], &["vitriol"], + &["virtual"], + &["virtualisation"], + &["virtualisation"], + &["virtualization"], + &["virtualization"], + &["virtualization"], &["virtually"], + &["virtual"], &["virtues"], &["virtues"], + &["virtual"], + &["virtue"], + &["virtual", "viral"], &["visualization"], &["virtual"], + &["virtualenv"], + &["virtualisation"], + &["virtualise"], + &["virtualised"], + &["virtualization"], + &["virtualize"], + &["virtualized"], &["virtually"], + &["virtuals"], &["virtues"], ], - range: 4..=10, + range: 3..=12, }; static WORD_VIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -1778,20 +3855,32 @@ static WORD_VIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 5..=6, + range: 4..=8, }; static WORD_VIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -1806,6 +3895,7 @@ pub static WORD_VIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dictave"), dictgen::InsensitiveStr::Ascii("dicte"), dictgen::InsensitiveStr::Ascii("icity"), + dictgen::InsensitiveStr::Ascii("rator"), ], values: &[ &["vicinity"], @@ -1813,6 +3903,7 @@ pub static WORD_VIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["vindictive"], &["vindictive"], &["vicinity"], + &["vibrator"], ], range: 5..=7, }; @@ -1826,6 +3917,7 @@ pub static WORD_VIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("igant"), dictgen::InsensitiveStr::Ascii("igante"), + dictgen::InsensitiveStr::Ascii("l"), dictgen::InsensitiveStr::Ascii("lageois"), dictgen::InsensitiveStr::Ascii("legas"), dictgen::InsensitiveStr::Ascii("lian"), @@ -1837,15 +3929,16 @@ pub static WORD_VIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["vigilant"], &["vigilante"], + &["will"], &["villages"], &["villages"], &["villain"], &["vilification"], &["vilify"], - &["villain"], + &["villain", "villi", "villein"], &["violently"], ], - range: 3..=10, + range: 1..=10, }; static WORD_VIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -1882,7 +3975,7 @@ pub static WORD_VIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rins"), ], values: &[ - &["vigueur"], + &["vigueur", "vigour", "vigour"], &["vigilante"], &["vigilante"], &["vigilante"], @@ -1906,9 +3999,12 @@ pub static WORD_VIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ 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"), @@ -1916,10 +4012,14 @@ pub static WORD_VIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("wpiont"), dictgen::InsensitiveStr::Ascii("wpionts"), dictgen::InsensitiveStr::Ascii("wpoit"), + dictgen::InsensitiveStr::Ascii("wtransfromation"), ], values: &[ &["vietnam"], &["vietnamese"], + &["viewport"], + &["viewports"], + &["vietnamese"], &["vietnamese"], &["vietnamese"], &["vietnamese"], @@ -1930,8 +4030,9 @@ pub static WORD_VIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["viewpoint"], &["viewpoints"], &["viewpoints"], + &["viewtransformation"], ], - range: 4..=8, + range: 4..=15, }; static WORD_VID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -1946,6 +4047,7 @@ pub static WORD_VID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("eogamemes"), dictgen::InsensitiveStr::Ascii("eogams"), dictgen::InsensitiveStr::Ascii("eojames"), + dictgen::InsensitiveStr::Ascii("eostreamming"), dictgen::InsensitiveStr::Ascii("oegame"), dictgen::InsensitiveStr::Ascii("oegames"), ], @@ -1955,10 +4057,11 @@ pub static WORD_VID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["videogames"], &["videogames"], &["videogames"], + &["videostreaming"], &["videogame"], &["videogames"], ], - range: 6..=9, + range: 6..=12, }; static WORD_VIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2050,9 +4153,21 @@ pub static WORD_VIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("biliy"), dictgen::InsensitiveStr::Ascii("tmin"), dictgen::InsensitiveStr::Ascii("tmins"), + dictgen::InsensitiveStr::Ascii("tnamese"), ], - values: &[&["viability"], &["vitamin"], &["vitamins"]], - range: 4..=5, + values: &[&["viability"], &["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 { @@ -2062,16 +4177,16 @@ static WORD_VE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_VE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ None, - None, + Some(&WORD_VEB_NODE), Some(&WORD_VEC_NODE), + Some(&WORD_VED_NODE), None, - None, - None, + Some(&WORD_VEF_NODE), Some(&WORD_VEG_NODE), Some(&WORD_VEH_NODE), Some(&WORD_VEI_NODE), None, - None, + Some(&WORD_VEK_NODE), Some(&WORD_VEL_NODE), None, Some(&WORD_VEN_NODE), @@ -2102,7 +4217,7 @@ pub static WORD_VEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict static WORD_VEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_VEW_CHILDREN), - value: None, + value: Some(&["view"]), }; pub static WORD_VEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -2117,9 +4232,13 @@ static WORD_VET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_VET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ween")], - values: &[&["between"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ex"), + dictgen::InsensitiveStr::Ascii("exes"), + dictgen::InsensitiveStr::Ascii("ween"), + ], + values: &[&["vertex"], &["vertices"], &["between"]], + range: 2..=4, }; static WORD_VES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2129,119 +4248,426 @@ static WORD_VES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["vessels"], &["vessels"], &["vessels"]], - range: 4..=5, + values: &[ + &["version"], + &["versions"], + &["vessels"], + &["vessels"], + &["vessels"], + ], + range: 3..=5, }; static WORD_VER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_VER_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_VER_CHILDREN), value: None, }; -pub static WORD_VER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_VER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_VERA_NODE), + Some(&WORD_VERB_NODE), + None, + None, + Some(&WORD_VERE_NODE), + Some(&WORD_VERF_NODE), + None, + None, + Some(&WORD_VERI_NODE), + None, + None, + Some(&WORD_VERL_NODE), + None, + 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("ablly"), - dictgen::InsensitiveStr::Ascii("astility"), - dictgen::InsensitiveStr::Ascii("baitm"), - dictgen::InsensitiveStr::Ascii("baly"), - dictgen::InsensitiveStr::Ascii("batium"), - dictgen::InsensitiveStr::Ascii("fication"), - dictgen::InsensitiveStr::Ascii("ficiation"), - dictgen::InsensitiveStr::Ascii("fiying"), - dictgen::InsensitiveStr::Ascii("ical"), - dictgen::InsensitiveStr::Ascii("ificacion"), - dictgen::InsensitiveStr::Ascii("ificaiton"), - dictgen::InsensitiveStr::Ascii("ificato"), - dictgen::InsensitiveStr::Ascii("ifikation"), - dictgen::InsensitiveStr::Ascii("ifiyng"), - dictgen::InsensitiveStr::Ascii("ifyable"), - dictgen::InsensitiveStr::Ascii("ious"), - dictgen::InsensitiveStr::Ascii("isions"), - dictgen::InsensitiveStr::Ascii("ison"), - dictgen::InsensitiveStr::Ascii("isons"), - dictgen::InsensitiveStr::Ascii("itcally"), - dictgen::InsensitiveStr::Ascii("itgo"), - dictgen::InsensitiveStr::Ascii("itiable"), - dictgen::InsensitiveStr::Ascii("naculaire"), - dictgen::InsensitiveStr::Ascii("necular"), - dictgen::InsensitiveStr::Ascii("nicular"), - dictgen::InsensitiveStr::Ascii("salite"), - dictgen::InsensitiveStr::Ascii("satality"), - dictgen::InsensitiveStr::Ascii("satel"), - dictgen::InsensitiveStr::Ascii("satiliy"), - dictgen::InsensitiveStr::Ascii("satille"), - dictgen::InsensitiveStr::Ascii("satillity"), - dictgen::InsensitiveStr::Ascii("satilty"), - dictgen::InsensitiveStr::Ascii("satily"), - dictgen::InsensitiveStr::Ascii("siones"), - dictgen::InsensitiveStr::Ascii("sitale"), - dictgen::InsensitiveStr::Ascii("sitality"), - dictgen::InsensitiveStr::Ascii("sitilaty"), - dictgen::InsensitiveStr::Ascii("sitlity"), - dictgen::InsensitiveStr::Ascii("soin"), - dictgen::InsensitiveStr::Ascii("staile"), - dictgen::InsensitiveStr::Ascii("tabim"), - dictgen::InsensitiveStr::Ascii("tgio"), - dictgen::InsensitiveStr::Ascii("ticallity"), - dictgen::InsensitiveStr::Ascii("ticaly"), - dictgen::InsensitiveStr::Ascii("tification"), - dictgen::InsensitiveStr::Ascii("tigro"), - dictgen::InsensitiveStr::Ascii("yifing"), + dictgen::InsensitiveStr::Ascii("fieng"), + dictgen::InsensitiveStr::Ascii("fy"), + dictgen::InsensitiveStr::Ascii("ified"), + dictgen::InsensitiveStr::Ascii("ifies"), + dictgen::InsensitiveStr::Ascii("ifing"), + dictgen::InsensitiveStr::Ascii("ify"), + dictgen::InsensitiveStr::Ascii("ifying"), ], values: &[ - &["verbally"], + &["verifying"], + &["verify"], + &["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("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("icle"), + dictgen::InsensitiveStr::Ascii("iclealign"), + 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"), + ], + values: &[ + &["verbatim"], + &["vertices"], + &["vertices"], + &["vertigo"], + &["vertical"], + &["vertical"], + &["vertically"], + &["vertically"], + &["vertices"], + &["vertical"], + &["verticalalign"], + &["vertex"], + &["vertices"], + &["verifiable"], + &["certification", "verification"], + &["verifications"], + &["verify"], + &["vertigo"], + &["vertical"], + &["vertex"], + &["vertices"], + &["vertices"], + ], + range: 2..=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("hin"), + dictgen::InsensitiveStr::Ascii("in"), + 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("itale"), + dictgen::InsensitiveStr::Ascii("itality"), + dictgen::InsensitiveStr::Ascii("itilaty"), + dictgen::InsensitiveStr::Ascii("itlity"), + dictgen::InsensitiveStr::Ascii("oin"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("oned"), + dictgen::InsensitiveStr::Ascii("ons"), + dictgen::InsensitiveStr::Ascii("taile"), + ], + values: &[ + &["versatile"], &["versatility"], - &["verbatim"], - &["verbally"], - &["verbatim"], + &["versatile"], + &["versatility"], + &["versatile"], + &["versatility"], + &["versatility"], + &["versatility"], + &["version"], + &["version"], + &["version"], + &["version"], + &["versioned"], + &["versioning"], + &["version"], + &["versionadded"], + &["versions"], + &["version"], + &["versions"], + &["versioned"], + &["versioning"], + &["versions"], + &["versatile"], + &["versatility"], + &["versatility"], + &["versatility"], + &["version"], + &["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_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("cal"), + dictgen::InsensitiveStr::Ascii("fi"), + dictgen::InsensitiveStr::Ascii("fiaction"), + dictgen::InsensitiveStr::Ascii("ficacion"), + dictgen::InsensitiveStr::Ascii("ficaiton"), + dictgen::InsensitiveStr::Ascii("ficato"), + dictgen::InsensitiveStr::Ascii("fie"), + dictgen::InsensitiveStr::Ascii("fikation"), + dictgen::InsensitiveStr::Ascii("fing"), + dictgen::InsensitiveStr::Ascii("fiyng"), + dictgen::InsensitiveStr::Ascii("fty"), + dictgen::InsensitiveStr::Ascii("ftying"), + dictgen::InsensitiveStr::Ascii("fyable"), + dictgen::InsensitiveStr::Ascii("fyied"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("ons"), + dictgen::InsensitiveStr::Ascii("osn"), + dictgen::InsensitiveStr::Ascii("osns"), + dictgen::InsensitiveStr::Ascii("ous"), + dictgen::InsensitiveStr::Ascii("sions"), + dictgen::InsensitiveStr::Ascii("son"), + dictgen::InsensitiveStr::Ascii("soned"), + 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: &[ + &["vertical"], + &["verify", "verified"], &["verification"], &["verification"], + &["verification"], + &["verification"], + &["verify", "verified"], + &["verification"], &["verifying"], - &["vertical"], - &["verification"], - &["verification"], - &["verification"], - &["verification"], + &["verifying"], + &["verify"], &["verifying"], &["verifiable"], + &["verified"], + &["version"], + &["versions"], + &["version"], + &["versions"], &["various"], &["revisions"], &["version"], + &["versioned"], &["versions"], + &["vertical"], &["vertically"], &["vertigo"], &["verifiable"], - &["vernacular"], - &["vernacular"], - &["vernacular"], - &["versatile"], - &["versatility"], - &["versatile"], - &["versatility"], - &["versatile"], - &["versatility"], - &["versatility"], - &["versatility"], - &["versions"], - &["versatile"], - &["versatility"], - &["versatility"], - &["versatility"], - &["version"], - &["versatile"], - &["verbatim"], - &["vertigo"], - &["vertically"], - &["vertically"], - &["certification"], - &["vertigo"], + &["vertical"], + ], + range: 2..=8, +}; + +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("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("iying"), + dictgen::InsensitiveStr::Ascii("y"), + dictgen::InsensitiveStr::Ascii("ying"), + ], + values: &[ + &["verification"], + &["verification"], + &["verifiable"], + &["verification"], + &["verifications"], + &["verified"], + &["verifier"], + &["verifiers"], + &["verifies"], + &["verify"], + &["verifying"], + &["verifying"], + &["verify"], &["verifying"], ], - range: 4..=10, + 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("sion"), + dictgen::InsensitiveStr::Ascii("sions"), + ], + values: &[&["version"], &["versions"]], + range: 4..=5, +}; + +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("aitm"), + dictgen::InsensitiveStr::Ascii("aly"), + dictgen::InsensitiveStr::Ascii("atium"), + dictgen::InsensitiveStr::Ascii("atum"), + dictgen::InsensitiveStr::Ascii("ous"), + dictgen::InsensitiveStr::Ascii("ouse"), + dictgen::InsensitiveStr::Ascii("ously"), + dictgen::InsensitiveStr::Ascii("se"), + ], + values: &[ + &["verbatim"], + &["verbally"], + &["verbatim"], + &["verbatim"], + &["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("stility"), + ], + values: &[&["verbally"], &["versatility"]], + range: 4..=7, }; static WORD_VEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2305,10 +4731,33 @@ static WORD_VEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_VEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("antine"), + dictgen::InsensitiveStr::Ascii("idate"), dictgen::InsensitiveStr::Ascii("l"), + dictgen::InsensitiveStr::Ascii("ociries"), + dictgen::InsensitiveStr::Ascii("ociry"), ], - values: &[&["valentine"], &["well"]], - range: 1..=6, + values: &[ + &["valentine"], + &["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 { @@ -2319,23 +4768,37 @@ static WORD_VEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_VEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("chles"), + 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"], + &["verify"], &["vietnam"], &["vietnamese"], + &["view"], + &["viewed"], + &["viewer"], &["viewers"], &["viewership"], + &["viewing"], + &["viewings"], &["viewpoint"], &["viewpoints"], + &["views"], ], - range: 4..=7, + range: 1..=7, }; static WORD_VEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2420,6 +4883,28 @@ pub static WORD_VEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -2428,12 +4913,47 @@ static WORD_VEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_VEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("hiles"), + dictgen::InsensitiveStr::Ascii("otr"), dictgen::InsensitiveStr::Ascii("otrs"), + dictgen::InsensitiveStr::Ascii("tore"), dictgen::InsensitiveStr::Ascii("tores"), dictgen::InsensitiveStr::Ascii("tros"), + dictgen::InsensitiveStr::Ascii("vtor"), + dictgen::InsensitiveStr::Ascii("vtors"), ], - values: &[&["vehicles"], &["vectors"], &["vectors"], &["vectors"]], - range: 4..=5, + values: &[ + &["vehicles"], + &["vector"], + &["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_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 { @@ -2442,7 +4962,7 @@ static WORD_VA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_VAA_NODE), None, Some(&WORD_VAC_NODE), None, @@ -2463,7 +4983,7 @@ static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_VAS_NODE), Some(&WORD_VAT_NODE), Some(&WORD_VAU_NODE), - None, + Some(&WORD_VAV_NODE), None, None, Some(&WORD_VAY_NODE), @@ -2481,6 +5001,29 @@ pub static WORD_VAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=5, }; +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, @@ -2488,11 +5031,24 @@ static WORD_VAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_VAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("e"), 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: &[&["vaguely"], &["valuable"]], - range: 4..=5, + values: &[ + &["value"], + &["vaguely"], + &["valuable"], + &["value"], + &["valued"], + &["values"], + &["valuing"], + ], + range: 1..=5, }; static WORD_VAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2511,7 +5067,7 @@ pub static WORD_VAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict static WORD_VAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_VAS_CHILDREN), - value: None, + value: Some(&["was"]), }; pub static WORD_VAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -2547,48 +5103,132 @@ static WORD_VAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_VAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("able"), + dictgen::InsensitiveStr::Ascii("ables"), + dictgen::InsensitiveStr::Ascii("aiable"), + dictgen::InsensitiveStr::Ascii("aiables"), + dictgen::InsensitiveStr::Ascii("aiance"), + dictgen::InsensitiveStr::Ascii("aiation"), dictgen::InsensitiveStr::Ascii("aible"), dictgen::InsensitiveStr::Ascii("aibles"), dictgen::InsensitiveStr::Ascii("aint"), dictgen::InsensitiveStr::Ascii("aints"), + dictgen::InsensitiveStr::Ascii("ation"), dictgen::InsensitiveStr::Ascii("ations"), dictgen::InsensitiveStr::Ascii("eity"), + dictgen::InsensitiveStr::Ascii("iabe"), dictgen::InsensitiveStr::Ascii("iabel"), + dictgen::InsensitiveStr::Ascii("iabele"), + dictgen::InsensitiveStr::Ascii("iabes"), + dictgen::InsensitiveStr::Ascii("ialbles"), + dictgen::InsensitiveStr::Ascii("ian"), dictgen::InsensitiveStr::Ascii("ians"), dictgen::InsensitiveStr::Ascii("iantes"), + dictgen::InsensitiveStr::Ascii("iantions"), + dictgen::InsensitiveStr::Ascii("iatinos"), + dictgen::InsensitiveStr::Ascii("iatoin"), + dictgen::InsensitiveStr::Ascii("iatoins"), + dictgen::InsensitiveStr::Ascii("ibable"), + dictgen::InsensitiveStr::Ascii("ibables"), dictgen::InsensitiveStr::Ascii("ibale"), + dictgen::InsensitiveStr::Ascii("ibales"), + dictgen::InsensitiveStr::Ascii("ibaless"), + dictgen::InsensitiveStr::Ascii("ibel"), + dictgen::InsensitiveStr::Ascii("ibels"), + dictgen::InsensitiveStr::Ascii("ibility"), + dictgen::InsensitiveStr::Ascii("iblae"), + dictgen::InsensitiveStr::Ascii("iblaes"), + dictgen::InsensitiveStr::Ascii("ible"), + dictgen::InsensitiveStr::Ascii("ibles"), + dictgen::InsensitiveStr::Ascii("ience"), dictgen::InsensitiveStr::Ascii("ient"), + dictgen::InsensitiveStr::Ascii("ients"), + dictgen::InsensitiveStr::Ascii("ierty"), dictgen::InsensitiveStr::Ascii("iey"), dictgen::InsensitiveStr::Ascii("ification"), + dictgen::InsensitiveStr::Ascii("iing"), dictgen::InsensitiveStr::Ascii("ing"), dictgen::InsensitiveStr::Ascii("isty"), dictgen::InsensitiveStr::Ascii("itey"), dictgen::InsensitiveStr::Ascii("ities"), dictgen::InsensitiveStr::Ascii("ity"), + dictgen::InsensitiveStr::Ascii("iuos"), + dictgen::InsensitiveStr::Ascii("iuous"), + dictgen::InsensitiveStr::Ascii("ius"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("ned"), + dictgen::InsensitiveStr::Ascii("ning"), + dictgen::InsensitiveStr::Ascii("nings"), + dictgen::InsensitiveStr::Ascii("ns"), + dictgen::InsensitiveStr::Ascii("oius"), dictgen::InsensitiveStr::Ascii("stiy"), + dictgen::InsensitiveStr::Ascii("tical"), + dictgen::InsensitiveStr::Ascii("tically"), ], values: &[ + &["variable"], + &["variables"], + &["variable"], + &["variables"], + &["variance"], + &["variation"], &["variable"], &["variables"], &["variant"], &["variants"], + &["variation"], &["variations"], &["variety"], &["variable"], - &["variants"], - &["variants"], &["variable"], + &["variable"], + &["variables"], + &["variables"], &["variant"], + &["variants"], + &["variants"], + &["variations"], + &["variations"], + &["variation"], + &["variations"], + &["variable"], + &["variables"], + &["variable"], + &["variables"], + &["variables"], + &["variable"], + &["variables"], + &["variability"], + &["variable"], + &["variables"], + &["variable"], + &["variables"], + &["variance"], + &["variant"], + &["variants"], + &["variety"], &["variety"], &["verification"], &["varying"], + &["varying"], &["varsity"], &["variety"], &["varieties"], &["variety"], + &["various"], + &["various"], + &["various"], + &["warn"], + &["warned"], + &["warning"], + &["warnings"], + &["warns"], + &["various"], &["varsity"], + &["vertical"], + &["vertically"], ], - range: 3..=9, + range: 1..=9, }; static WORD_VAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2605,6 +5245,7 @@ pub static WORD_VAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("gurad"), dictgen::InsensitiveStr::Ascii("illia"), dictgen::InsensitiveStr::Ascii("illla"), + dictgen::InsensitiveStr::Ascii("ishs"), dictgen::InsensitiveStr::Ascii("ugard"), ], values: &[ @@ -2615,6 +5256,7 @@ pub static WORD_VAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["vanguard"], &["vanilla"], &["vanilla"], + &["vanishes"], &["vanguard"], ], range: 4..=7, @@ -2643,6 +5285,8 @@ static WORD_VAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_VAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ailable"), + dictgen::InsensitiveStr::Ascii("date"), dictgen::InsensitiveStr::Ascii("diated"), dictgen::InsensitiveStr::Ascii("enca"), dictgen::InsensitiveStr::Ascii("enica"), @@ -2658,24 +5302,48 @@ pub static WORD_VAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("entis"), dictgen::InsensitiveStr::Ascii("entones"), dictgen::InsensitiveStr::Ascii("etta"), + dictgen::InsensitiveStr::Ascii("iator"), dictgen::InsensitiveStr::Ascii("idade"), + dictgen::InsensitiveStr::Ascii("idaterelase"), + dictgen::InsensitiveStr::Ascii("ide"), + dictgen::InsensitiveStr::Ascii("ididty"), + dictgen::InsensitiveStr::Ascii("iding"), dictgen::InsensitiveStr::Ascii("iditity"), dictgen::InsensitiveStr::Ascii("iditiy"), + dictgen::InsensitiveStr::Ascii("ied"), + dictgen::InsensitiveStr::Ascii("ies"), + dictgen::InsensitiveStr::Ascii("if"), + dictgen::InsensitiveStr::Ascii("itdity"), dictgen::InsensitiveStr::Ascii("kirye"), dictgen::InsensitiveStr::Ascii("kiyre"), dictgen::InsensitiveStr::Ascii("kriye"), dictgen::InsensitiveStr::Ascii("kryie"), + dictgen::InsensitiveStr::Ascii("kues"), dictgen::InsensitiveStr::Ascii("kyire"), dictgen::InsensitiveStr::Ascii("kyre"), + dictgen::InsensitiveStr::Ascii("lid"), + dictgen::InsensitiveStr::Ascii("lidation"), + dictgen::InsensitiveStr::Ascii("lidity"), + dictgen::InsensitiveStr::Ascii("lue"), + dictgen::InsensitiveStr::Ascii("lues"), dictgen::InsensitiveStr::Ascii("necia"), dictgen::InsensitiveStr::Ascii("netines"), + dictgen::InsensitiveStr::Ascii("tage"), + dictgen::InsensitiveStr::Ascii("tages"), + dictgen::InsensitiveStr::Ascii("u"), dictgen::InsensitiveStr::Ascii("uabe"), dictgen::InsensitiveStr::Ascii("ubale"), dictgen::InsensitiveStr::Ascii("uble"), + dictgen::InsensitiveStr::Ascii("udes"), dictgen::InsensitiveStr::Ascii("ueable"), + dictgen::InsensitiveStr::Ascii("uess"), + dictgen::InsensitiveStr::Ascii("uie"), + dictgen::InsensitiveStr::Ascii("use"), dictgen::InsensitiveStr::Ascii("ykrie"), ], values: &[ + &["available"], + &["validate"], &["validated"], &["valencia"], &["valencia"], @@ -2691,24 +5359,46 @@ pub static WORD_VAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["valentines"], &["valentines"], &["valletta"], + &["validator"], &["validated"], + &["validaterelease"], + &["valid"], &["validity"], + &["validating"], + &["validity"], + &["validity"], + &["valid"], + &["values"], + &["valid"], &["validity"], &["valkyrie"], &["valkyrie"], &["valkyrie"], &["valkyrie"], + &["values"], &["valkyrie"], &["valkyrie"], + &["valid"], + &["validation"], + &["validity"], + &["value"], + &["values"], &["valencia"], &["valentines"], + &["voltage"], + &["voltages"], + &["value"], &["valuable"], &["valuable"], &["valuable"], + &["values"], &["valuable"], + &["values"], + &["value"], + &["values", "value"], &["valkyrie"], ], - range: 4..=7, + range: 1..=11, }; static WORD_VAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2717,9 +5407,14 @@ static WORD_VAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_VAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lyrie")], - values: &[&["valkyrie"]], - range: 5..=5, + 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 { @@ -2729,26 +5424,44 @@ static WORD_VAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], &["varieties"], + &["available"], + &["valid"], &["validated"], &["validity"], + &["validity"], &["variable"], &["variables"], &["variant"], + &["various"], ], - range: 4..=6, + range: 1..=6, }; static WORD_VAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2786,8 +5499,13 @@ pub static WORD_VAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("cins"), dictgen::InsensitiveStr::Ascii("cum"), dictgen::InsensitiveStr::Ascii("cume"), + dictgen::InsensitiveStr::Ascii("cuum"), dictgen::InsensitiveStr::Ascii("estomy"), dictgen::InsensitiveStr::Ascii("inity"), + dictgen::InsensitiveStr::Ascii("tor"), + dictgen::InsensitiveStr::Ascii("tors"), + dictgen::InsensitiveStr::Ascii("umme"), + dictgen::InsensitiveStr::Ascii("uosly"), ], values: &[ &["vaccinate"], @@ -2802,12 +5520,28 @@ pub static WORD_VAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["vaccines"], &["vacuum"], &["vacuum"], + &["vacuum"], &["vasectomy"], &["vicinity"], + &["vector"], + &["vectors"], + &["vacuum"], + &["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, @@ -2834,7 +5568,7 @@ static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_UR_NODE), Some(&WORD_US_NODE), Some(&WORD_UT_NODE), - None, + Some(&WORD_UU_NODE), None, None, None, @@ -2842,6 +5576,17 @@ static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> 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")], + values: &[&["upload"]], + range: 5..=5, +}; + static WORD_UT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_UT_CHILDREN), value: None, @@ -2849,40 +5594,98 @@ static WORD_UT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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("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"], - &["utilitarian"], + &["utilities"], + &["utilisation"], + &["utilise"], + &["utilises"], + &["utilising"], &["utility"], &["utilization"], + &["utilize"], + &["utilizes"], + &["utilizing"], + &["utilize"], + &["utilize"], &["utilization"], &["utilization"], + &["utilization"], + &["utilization"], + &["utilities"], &["utilitarian"], + &["utilities"], + &["utilities"], + &["utility"], + &["utility"], + &["utility"], + &["utility"], &["utility"], &["ultimate"], &["ultimately"], &["ultimatum"], + &["utilities"], + &["utility"], &["ultrasound"], &["utopian"], &["utopian"], + &["output"], + &["outputs"], ], - range: 5..=9, + range: 3..=11, }; static WORD_US_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2892,22 +5695,110 @@ static WORD_US_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_US_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("al"), dictgen::InsensitiveStr::Ascii("ally"), + dictgen::InsensitiveStr::Ascii("caled"), dictgen::InsensitiveStr::Ascii("eage"), + dictgen::InsensitiveStr::Ascii("ebility"), + dictgen::InsensitiveStr::Ascii("eble"), + dictgen::InsensitiveStr::Ascii("eed"), + dictgen::InsensitiveStr::Ascii("ees"), + dictgen::InsensitiveStr::Ascii("efule"), + dictgen::InsensitiveStr::Ascii("efullness"), + dictgen::InsensitiveStr::Ascii("efult"), dictgen::InsensitiveStr::Ascii("efuly"), + dictgen::InsensitiveStr::Ascii("efutl"), + dictgen::InsensitiveStr::Ascii("eg"), + dictgen::InsensitiveStr::Ascii("ege"), dictgen::InsensitiveStr::Ascii("eing"), + dictgen::InsensitiveStr::Ascii("era"), + dictgen::InsensitiveStr::Ascii("erapace"), + dictgen::InsensitiveStr::Ascii("erful"), + dictgen::InsensitiveStr::Ascii("erpace"), + dictgen::InsensitiveStr::Ascii("erpsace"), + dictgen::InsensitiveStr::Ascii("ersapce"), + dictgen::InsensitiveStr::Ascii("erspase"), + dictgen::InsensitiveStr::Ascii("esfull"), + dictgen::InsensitiveStr::Ascii("espace"), + dictgen::InsensitiveStr::Ascii("etnet"), + dictgen::InsensitiveStr::Ascii("ibility"), + dictgen::InsensitiveStr::Ascii("ible"), + dictgen::InsensitiveStr::Ascii("ig"), + dictgen::InsensitiveStr::Ascii("ign"), + dictgen::InsensitiveStr::Ascii("iing"), + dictgen::InsensitiveStr::Ascii("in"), + dictgen::InsensitiveStr::Ascii("ind"), + dictgen::InsensitiveStr::Ascii("inging"), + dictgen::InsensitiveStr::Ascii("inng"), + dictgen::InsensitiveStr::Ascii("ng"), + dictgen::InsensitiveStr::Ascii("pported"), + dictgen::InsensitiveStr::Ascii("seful"), + dictgen::InsensitiveStr::Ascii("sual"), + dictgen::InsensitiveStr::Ascii("suall"), + dictgen::InsensitiveStr::Ascii("sually"), + dictgen::InsensitiveStr::Ascii("uable"), + dictgen::InsensitiveStr::Ascii("uage"), + dictgen::InsensitiveStr::Ascii("uall"), + dictgen::InsensitiveStr::Ascii("uallly"), dictgen::InsensitiveStr::Ascii("ualy"), + dictgen::InsensitiveStr::Ascii("ueful"), + dictgen::InsensitiveStr::Ascii("upported"), + dictgen::InsensitiveStr::Ascii("usal"), dictgen::InsensitiveStr::Ascii("usally"), ], values: &[ + &["usual"], &["usually"], + &["unscaled"], &["usage"], + &["usability"], + &["usable"], + &["used"], + &["uses"], + &["useful"], + &["usefulness"], + &["useful"], &["usefully"], + &["useful"], + &["user", "usage"], + &["usage"], &["using"], + &["users"], + &["userspace"], + &["useful"], + &["userspace"], + &["userspace"], + &["userspace"], + &["userspace"], + &["useful"], + &["userspace"], + &["usenet"], + &["usability"], + &["usable"], + &["using"], + &["using", "unsign"], + &["using"], + &["using"], + &["using"], + &["using"], + &["using"], + &["using"], + &["supported", "unsupported"], + &["useful"], + &["usual"], + &["usual"], &["usually"], + &["usable"], + &["usage"], + &["usually", "usual"], + &["usually"], + &["usually"], + &["useful"], + &["unsupported"], + &["usual"], &["usually"], ], - range: 4..=6, + range: 2..=9, }; static WORD_UR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -2919,69 +5810,444 @@ pub static WORD_UR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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: 5..=8, + range: 1..=8, }; static WORD_UP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_UP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_UP_CHILDREN), value: None, }; -pub static WORD_UP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("comming"), - dictgen::InsensitiveStr::Ascii("garde"), - dictgen::InsensitiveStr::Ascii("garded"), - dictgen::InsensitiveStr::Ascii("gardes"), - dictgen::InsensitiveStr::Ascii("garding"), - dictgen::InsensitiveStr::Ascii("gradded"), - dictgen::InsensitiveStr::Ascii("grads"), - dictgen::InsensitiveStr::Ascii("laods"), - dictgen::InsensitiveStr::Ascii("lfiting"), - dictgen::InsensitiveStr::Ascii("lifitng"), - dictgen::InsensitiveStr::Ascii("loades"), - dictgen::InsensitiveStr::Ascii("staris"), - dictgen::InsensitiveStr::Ascii("steam"), - dictgen::InsensitiveStr::Ascii("stiars"), + 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: &[ - &["upcoming"], + &["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("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"], + &["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("gaded"), + ], + values: &[&["upgrade"], &["upgraded"]], + range: 3..=5, +}; + +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("ler"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("orted"), + dictgen::InsensitiveStr::Ascii("orterd"), + 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: &[ + &["upper"], + &["upon"], + &["supported"], + &["supported"], + &["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("arde"), + dictgen::InsensitiveStr::Ascii("arded"), + dictgen::InsensitiveStr::Ascii("ardes"), + dictgen::InsensitiveStr::Ascii("arding"), + dictgen::InsensitiveStr::Ascii("arte"), + dictgen::InsensitiveStr::Ascii("radded"), + dictgen::InsensitiveStr::Ascii("radei"), + dictgen::InsensitiveStr::Ascii("radingn"), + dictgen::InsensitiveStr::Ascii("rads"), + dictgen::InsensitiveStr::Ascii("rate"), + ], + values: &[ + &["upgrade"], &["upgrade"], &["upgraded"], &["upgrades"], &["upgrading"], + &["upgrade"], &["upgraded"], + &["upgrade"], + &["upgrading"], &["upgrades"], - &["uploads"], - &["uplifting"], - &["uplifting"], - &["uploads"], - &["upstairs"], - &["upstream"], - &["upstairs"], + &["upgrade"], ], - range: 5..=7, + range: 3..=7, +}; + +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("rclass")], + values: &[&["upperclass"]], + range: 6..=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("at"), + dictgen::InsensitiveStr::Ascii("ateded"), + dictgen::InsensitiveStr::Ascii("ateed"), + dictgen::InsensitiveStr::Ascii("atees"), + dictgen::InsensitiveStr::Ascii("ateing"), + dictgen::InsensitiveStr::Ascii("atig"), + dictgen::InsensitiveStr::Ascii("ats"), + dictgen::InsensitiveStr::Ascii("grade"), + dictgen::InsensitiveStr::Ascii("rage"), + dictgen::InsensitiveStr::Ascii("te"), + ], + values: &[ + &["update"], + &["updated"], + &["updated"], + &["updates"], + &["updating"], + &["updating"], + &["updates"], + &["upgrade"], + &["upgrade"], + &["update"], + ], + range: 2..=6, +}; + +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("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"], + &["update"], + &["updated"], + &["updater"], + &["updates"], + &["updating"], + ], + range: 2..=6, }; static WORD_UN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3013,11 +6279,37 @@ static WORD_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_UNU_NODE), Some(&WORD_UNV_NODE), Some(&WORD_UNW_NODE), + Some(&WORD_UNX_NODE), None, - None, - 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, @@ -3032,7 +6324,9 @@ pub static WORD_UNW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("orhty"), dictgen::InsensitiveStr::Ascii("orthly"), dictgen::InsensitiveStr::Ascii("orty"), + dictgen::InsensitiveStr::Ascii("raped"), dictgen::InsensitiveStr::Ascii("rittern"), + dictgen::InsensitiveStr::Ascii("rritten"), ], values: &[ &["unwarranted"], @@ -3042,6 +6336,8 @@ pub static WORD_UNW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unworthy"], &["unworthy"], &["unworthy"], + &["unwrapped"], + &["unwritten"], &["unwritten"], ], range: 4..=8, @@ -3054,8 +6350,14 @@ static WORD_UNV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -3064,8 +6366,14 @@ pub static WORD_UNV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ulnerable"), ], values: &[ + &["unavailable"], + &["invalid"], + &["invalidate"], &["unbelievable"], &["unbelievably"], + &["unverified"], + &["unversioned"], + &["unversioned"], &["universally"], &["universe"], &["universes"], @@ -3073,7 +6381,7 @@ pub static WORD_UNV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["university"], &["invulnerable"], ], - range: 5..=9, + range: 4..=9, }; static WORD_UNU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3083,20 +6391,34 @@ static WORD_UNU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("seful"), + dictgen::InsensitiveStr::Ascii("sre"), dictgen::InsensitiveStr::Ascii("suable"), dictgen::InsensitiveStr::Ascii("sualy"), ], values: &[ + &["unused"], + &["unused"], + &["unusual"], &["unusable"], + &["unusual"], + &["unusually"], &["unusually"], &["unusable"], + &["useless"], + &["unsure"], &["unusable"], &["unusually"], ], - range: 4..=6, + range: 2..=6, }; static WORD_UNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3106,18 +6428,40 @@ static WORD_UNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 3..=12, + range: 2..=12, }; static WORD_UNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3126,14 +6470,14 @@ static WORD_UNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_UNSA_NODE), None, - None, - None, + Some(&WORD_UNSC_NODE), None, Some(&WORD_UNSE_NODE), None, None, - None, + Some(&WORD_UNSH_NODE), Some(&WORD_UNSI_NODE), None, None, @@ -3141,128 +6485,474 @@ static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_UNSO_NODE), + Some(&WORD_UNSP_NODE), None, None, None, - None, - None, + 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_UNSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_UNSU_CHILDREN), +static WORD_UNSUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_UNSUS_CHILDREN), value: None, }; -pub static WORD_UNSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("able"), - dictgen::InsensitiveStr::Ascii("bscibe"), - dictgen::InsensitiveStr::Ascii("bscirbe"), - dictgen::InsensitiveStr::Ascii("bscirbed"), - dictgen::InsensitiveStr::Ascii("bscrbe"), - dictgen::InsensitiveStr::Ascii("bscrbed"), - dictgen::InsensitiveStr::Ascii("bscribade"), - dictgen::InsensitiveStr::Ascii("bscribbed"), - dictgen::InsensitiveStr::Ascii("bscrible"), - dictgen::InsensitiveStr::Ascii("bscrided"), - dictgen::InsensitiveStr::Ascii("bscried"), - dictgen::InsensitiveStr::Ascii("bscripe"), - dictgen::InsensitiveStr::Ascii("bscriped"), - dictgen::InsensitiveStr::Ascii("bscrive"), - dictgen::InsensitiveStr::Ascii("bscrube"), - dictgen::InsensitiveStr::Ascii("bscrubed"), - dictgen::InsensitiveStr::Ascii("bsrcibe"), - dictgen::InsensitiveStr::Ascii("bsrcibed"), - dictgen::InsensitiveStr::Ascii("bstanciated"), - dictgen::InsensitiveStr::Ascii("bstansiated"), - dictgen::InsensitiveStr::Ascii("bstantiaed"), - dictgen::InsensitiveStr::Ascii("bstantianted"), - dictgen::InsensitiveStr::Ascii("bstantiative"), - dictgen::InsensitiveStr::Ascii("ccesful"), - dictgen::InsensitiveStr::Ascii("ccesfully"), - dictgen::InsensitiveStr::Ascii("ccessfull"), - dictgen::InsensitiveStr::Ascii("ccessul"), - dictgen::InsensitiveStr::Ascii("cesful"), - dictgen::InsensitiveStr::Ascii("cesfuly"), - dictgen::InsensitiveStr::Ascii("cessful"), - dictgen::InsensitiveStr::Ascii("cessfull"), - dictgen::InsensitiveStr::Ascii("cessfully"), - dictgen::InsensitiveStr::Ascii("nscribe"), - dictgen::InsensitiveStr::Ascii("nscribed"), - dictgen::InsensitiveStr::Ascii("prised"), - dictgen::InsensitiveStr::Ascii("prising"), - dictgen::InsensitiveStr::Ascii("prisingly"), dictgen::InsensitiveStr::Ascii("prized"), dictgen::InsensitiveStr::Ascii("prizing"), dictgen::InsensitiveStr::Ascii("prizingly"), - dictgen::InsensitiveStr::Ascii("rprized"), - dictgen::InsensitiveStr::Ascii("rprizing"), - dictgen::InsensitiveStr::Ascii("rprizingly"), - dictgen::InsensitiveStr::Ascii("sbcribe"), - dictgen::InsensitiveStr::Ascii("sbcribed"), - dictgen::InsensitiveStr::Ascii("sbtantiated"), - dictgen::InsensitiveStr::Ascii("stainble"), - dictgen::InsensitiveStr::Ascii("stainible"), - dictgen::InsensitiveStr::Ascii("stianable"), + ], + 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("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: &[ - &["unusable"], - &["unsubscribe"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubscribed"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubscribed"], - &["unsubscribed"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubscribe"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubstantiated"], - &["unsubstantiated"], - &["unsubstantiated"], - &["unsubstantiated"], - &["unsubstantiated"], - &["unsuccessful"], - &["unsuccessfully"], - &["unsuccessful"], - &["unsuccessful"], - &["unsuccessful"], - &["unsuccessfully"], - &["unsuccessful"], - &["unsuccessful"], - &["unsuccessfully"], - &["unsubscribe"], - &["unsubscribed"], + &["unsupportable"], + &["unsupported"], + &["unsupported"], + &["unsupported"], + &["unsuppress"], + &["unsuppressed"], + &["unsuppresses"], &["unsurprised"], &["unsurprising"], &["unsurprisingly"], &["unsurprised"], &["unsurprising"], &["unsurprisingly"], - &["unsurprised"], - &["unsurprising"], - &["unsurprisingly"], - &["unsubscribe"], - &["unsubscribed"], - &["unsubstantiated"], - &["unsustainable"], - &["unsustainable"], - &["unsustainable"], ], - range: 4..=12, + 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("cesful"), + dictgen::InsensitiveStr::Ascii("cesfull"), + dictgen::InsensitiveStr::Ascii("cesfully"), + 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"], + &["unsuccessfully"], + &["unsuccessful"], + &["unsuccessfully"], + &["unsuccessful"], + &["unsuccessful"], + &["unsuccessful"], + &["unsuccessfully"], + &["unsuccessfully"], + &["unsuccessfully"], + &["unsuccessfully"], + &["unsuccessfully"], + &["unsuccessful"], + &["unsuccessful"], + &["unsuccessfully"], + &["unsuccessfully"], + &["unsuccessful"], + &["unsuccessful"], + &["unsuccessfully"], + &["unsuccessfully"], + &["unsuccessful"], + &["unsuccessfully"], + &["unsuccessfully"], + ], + range: 5..=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("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"], + &["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("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"), + ], + values: &[ + &["unstable"], + &["install", "uninstall"], + &["installation", "uninstallation"], + &["installed", "uninstalled"], + &["installer", "uninstaller"], + &["installs", "uninstalls"], + &["installing", "uninstalling"], + &["installs", "uninstalls"], + ], + range: 3..=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("ecificed"), + 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: &[ + &["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 { @@ -3272,6 +6962,7 @@ static WORD_UNSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -3286,6 +6977,7 @@ pub static WORD_UNSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["unsolicited"], &["unsolicited"], &["unsolicited"], + &["unsolicited"], ], range: 6..=8, }; @@ -3299,16 +6991,33 @@ pub static WORD_UNSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("bscribed"), dictgen::InsensitiveStr::Ascii("bstantiated"), + dictgen::InsensitiveStr::Ascii("ged"), + dictgen::InsensitiveStr::Ascii("gnificant"), + dictgen::InsensitiveStr::Ascii("nged"), dictgen::InsensitiveStr::Ascii("ntalled"), dictgen::InsensitiveStr::Ascii("stainable"), ], values: &[ &["unsubscribed"], &["unsubstantiated"], + &["unsigned"], + &["insignificant"], + &["unsigned"], &["uninstalled"], &["unsustainable"], ], - range: 7..=11, + range: 3..=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")], + values: &[&["unshareable"]], + range: 6..=6, }; static WORD_UNSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3318,102 +7027,247 @@ static WORD_UNSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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("ttin"), dictgen::InsensitiveStr::Ascii("ttleing"), ], values: &[ + &["unsearchable"], &["unsuccessful"], - &["used"], + &["used", "unused"], + &["unselected"], + &["unselects"], + &["unselecting"], + &["unselects"], + &["unselect"], + &["unselected"], + &["unselects"], + &["unselecting"], + &["unselects"], + &["unselectable"], &["uncensored"], + &["unspecified"], + &["under", "unset", "unsure", "user"], &["unsuspecting"], + &["unsetting"], &["unsettling"], + &["unsetting"], &["unsettling"], ], range: 1..=8, }; -static WORD_UNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_UNR_CHILDREN), +static WORD_UNSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_UNSC_CHILDREN), value: None, }; -pub static WORD_UNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_UNSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("akned"), - dictgen::InsensitiveStr::Ascii("ankend"), - dictgen::InsensitiveStr::Ascii("ealesed"), - dictgen::InsensitiveStr::Ascii("ealible"), - dictgen::InsensitiveStr::Ascii("ealisitc"), - dictgen::InsensitiveStr::Ascii("ealisitic"), - dictgen::InsensitiveStr::Ascii("ealistc"), - dictgen::InsensitiveStr::Ascii("ealistisch"), - dictgen::InsensitiveStr::Ascii("ealitic"), - dictgen::InsensitiveStr::Ascii("ealsitic"), - dictgen::InsensitiveStr::Ascii("eaponsive"), - dictgen::InsensitiveStr::Ascii("easonablely"), - dictgen::InsensitiveStr::Ascii("easonabley"), - dictgen::InsensitiveStr::Ascii("easonablly"), - dictgen::InsensitiveStr::Ascii("easonal"), - dictgen::InsensitiveStr::Ascii("easonalby"), - dictgen::InsensitiveStr::Ascii("easonbly"), - dictgen::InsensitiveStr::Ascii("egluated"), - dictgen::InsensitiveStr::Ascii("egualted"), - dictgen::InsensitiveStr::Ascii("egulared"), - dictgen::InsensitiveStr::Ascii("elaible"), - dictgen::InsensitiveStr::Ascii("eleated"), - dictgen::InsensitiveStr::Ascii("eliabe"), - dictgen::InsensitiveStr::Ascii("elyable"), - dictgen::InsensitiveStr::Ascii("epentent"), - dictgen::InsensitiveStr::Ascii("epetant"), - dictgen::InsensitiveStr::Ascii("epetent"), - dictgen::InsensitiveStr::Ascii("epsonsive"), - dictgen::InsensitiveStr::Ascii("esponcive"), - dictgen::InsensitiveStr::Ascii("esponisve"), - dictgen::InsensitiveStr::Ascii("esponive"), - dictgen::InsensitiveStr::Ascii("esponse"), - dictgen::InsensitiveStr::Ascii("esponsibe"), - dictgen::InsensitiveStr::Ascii("esponsivness"), - dictgen::InsensitiveStr::Ascii("estircted"), - dictgen::InsensitiveStr::Ascii("estrcited"), - dictgen::InsensitiveStr::Ascii("estriced"), - dictgen::InsensitiveStr::Ascii("estrictred"), - dictgen::InsensitiveStr::Ascii("istricted"), - dictgen::InsensitiveStr::Ascii("naked"), - dictgen::InsensitiveStr::Ascii("poven"), - dictgen::InsensitiveStr::Ascii("witten"), + 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")], + values: &[&["unusable", "usable", "unstable"]], + 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("onable"), + 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: &[ - &["unranked"], - &["unranked"], - &["unreleased"], - &["unreliable"], - &["unrealistic"], - &["unrealistic"], - &["unrealistic"], - &["unrealistic"], - &["unrealistic"], - &["unrealistic"], - &["unresponsive"], - &["unreasonably"], - &["unreasonably"], - &["unreasonably"], - &["unreasonably"], - &["unreasonably"], - &["unreasonably"], - &["unregulated"], - &["unregulated"], - &["unregulated"], - &["unreliable"], - &["unreleased"], - &["unreliable"], - &["unreliable"], - &["unrepentant"], - &["unrepentant"], - &["unrepentant"], + &["unregister"], + &["unregistered"], + &["unregistered"], + &["unregisters"], + &["unreasonable"], &["unresponsive"], &["unresponsive"], &["unresponsive"], @@ -3425,12 +7279,248 @@ pub static WORD_UNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unrestricted"], &["unrestricted"], &["unrestricted"], - &["unrestricted"], - &["unranked"], - &["unproven"], - &["unwritten"], ], - range: 5..=12, + 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"], + &["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("onized"), + dictgen::InsensitiveStr::Ascii("ovable"), + dictgen::InsensitiveStr::Ascii("ovarable"), + dictgen::InsensitiveStr::Ascii("overd"), + ], + values: &[ + &["unreachable"], + &["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 { @@ -3441,17 +7531,29 @@ static WORD_UNQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 5..=8, + range: 2..=8, }; static WORD_UNP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3461,13 +7563,20 @@ static WORD_UNP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("erturbated"), 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"), @@ -3475,15 +7584,20 @@ pub static WORD_UNP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("recendented"), dictgen::InsensitiveStr::Ascii("recendeted"), dictgen::InsensitiveStr::Ascii("recidented"), + dictgen::InsensitiveStr::Ascii("recise"), dictgen::InsensitiveStr::Ascii("redecented"), + 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("riviliged"), + dictgen::InsensitiveStr::Ascii("rmopted"), dictgen::InsensitiveStr::Ascii("roducive"), dictgen::InsensitiveStr::Ascii("roduktive"), dictgen::InsensitiveStr::Ascii("rofessinal"), @@ -3494,10 +7608,17 @@ pub static WORD_UNP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rotexted"), ], values: &[ + &["unpacked"], + &["unpacked"], + &["unparsable"], + &["unperturbed"], + &["unperturbed"], &["unplayable"], &["unplayable"], &["unplayable"], &["unplayable"], + &["displease"], + &["unpleasant"], &["unpleasant"], &["unpleasant"], &["unpleasant"], @@ -3508,15 +7629,20 @@ pub static WORD_UNP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unprecedented"], &["unprecedented"], &["unprecedented"], + &["imprecise"], &["unprecedented"], &["unpredictable"], &["unpredictable"], &["unpredictable"], + &["unpredictability"], + &["unpredictable"], &["unproductive"], &["unprepared"], &["unprepared"], &["unprecedented"], &["unpredictable"], + &["unprivileged"], + &["unprompted"], &["unproductive"], &["unproductive"], &["unprofessional"], @@ -3536,34 +7662,44 @@ static WORD_UNO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_UNO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cde"), dictgen::InsensitiveStr::Ascii("fficail"), dictgen::InsensitiveStr::Ascii("ffical"), dictgen::InsensitiveStr::Ascii("ffocial"), + dictgen::InsensitiveStr::Ascii("in"), + dictgen::InsensitiveStr::Ascii("mpress"), dictgen::InsensitiveStr::Ascii("pend"), dictgen::InsensitiveStr::Ascii("penend"), dictgen::InsensitiveStr::Ascii("perational"), + dictgen::InsensitiveStr::Ascii("rderd"), 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: &[ + &["unicode"], &["unofficial"], &["unofficial"], &["unofficial"], + &["union"], + &["uncompress"], &["unopened"], &["unopened"], &["nonoperational"], + &["unordered"], &["unoriginal"], &["unoriginal"], &["unoriginal"], &["unoriginal"], &["unoriginal"], + &["unrotated"], &["unnoticeable"], ], - range: 4..=10, + range: 2..=10, }; static WORD_UNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3573,16 +7709,23 @@ static WORD_UNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ecesarily"), + dictgen::InsensitiveStr::Ascii("ecesarrily"), + dictgen::InsensitiveStr::Ascii("ecesarry"), dictgen::InsensitiveStr::Ascii("ecesary"), dictgen::InsensitiveStr::Ascii("ecessairly"), dictgen::InsensitiveStr::Ascii("ecessairy"), + dictgen::InsensitiveStr::Ascii("ecessar"), dictgen::InsensitiveStr::Ascii("ecessarely"), dictgen::InsensitiveStr::Ascii("ecessarilly"), dictgen::InsensitiveStr::Ascii("ecessarity"), @@ -3591,13 +7734,31 @@ pub static WORD_UNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ecessery"), 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("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("supported"), ], values: &[ + &["unacquired"], + &["unnecessary"], &["unnecessarily"], &["unnecessary"], &["unnecessarily"], @@ -3608,6 +7769,11 @@ pub static WORD_UNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unnecessary"], &["unnecessarily"], &["unnecessarily"], + &["unnecessary"], + &["unnecessary"], + &["unnecessarily"], + &["unnecessarily"], + &["unnecessary"], &["unnecessarily"], &["unnecessarily"], &["unnecessarily"], @@ -3616,13 +7782,29 @@ pub static WORD_UNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unnecessary"], &["unnecessarily"], &["unnecessary"], + &["unnecessary"], + &["unneeded"], + &["unneeded"], + &["unnecessarily"], &["unnecessarily"], &["unnecessary"], + &["unnecessarily"], + &["unnecessary"], + &["unnecessarily"], + &["unnecessary"], + &["unnecessary"], + &["unnecessarily"], + &["unnecessary"], + &["unnecessarily"], + &["unnecessary"], + &["running"], &["uninstall"], &["uninstalled"], &["uninstalling"], + &["unnecessary"], + &["unsupported"], ], - range: 6..=11, + range: 3..=11, }; static WORD_UNM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3631,9 +7813,43 @@ static WORD_UNM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_UNM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("anouverable")], - values: &[&["unmaneuverable"]], - range: 11..=11, + 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("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"], + &["unmistakably"], + &["unmodified"], + &["unmodified"], + &["unmodified"], + &["unmodified"], + &["unmodified"], + &["unmodified"], + &["unmodifiable"], + &["unmodified"], + &["unmounted"], + ], + range: 5..=11, }; static WORD_UNL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3644,25 +7860,37 @@ static WORD_UNL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_UNL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("cean"), + dictgen::InsensitiveStr::Ascii("cear"), dictgen::InsensitiveStr::Ascii("coks"), dictgen::InsensitiveStr::Ascii("cuky"), + dictgen::InsensitiveStr::Ascii("es"), dictgen::InsensitiveStr::Ascii("iaterally"), dictgen::InsensitiveStr::Ascii("ikey"), dictgen::InsensitiveStr::Ascii("ikley"), + 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: &[ &["unclean"], + &["unclear"], &["unlocks"], &["unlucky"], + &["unless"], &["unilaterally"], &["unlikely"], &["unlikely"], + &["unlimited"], + &["unlimited"], + &["unlike"], + &["unloading"], &["unlocks"], &["unlucky"], ], - range: 4..=9, + range: 2..=9, }; static WORD_UNK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3672,22 +7900,48 @@ static WORD_UNK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("nowingy"), dictgen::InsensitiveStr::Ascii("nowinlgy"), dictgen::InsensitiveStr::Ascii("nowinly"), + 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("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"], &["unknowingly"], &["unknowingly"], &["unknowingly"], &["unknown"], + &["unknowns"], + &["unknowing"], + &["unknowingly"], &["unknown"], + &["unknowns"], + &["unknown"], + &["unknowns"], &["unknown"], &["unknowingly"], + &["unknowns"], + &["unknown"], ], range: 3..=8, }; @@ -3715,10 +7969,10 @@ static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_UNIC_NODE), - None, + Some(&WORD_UNID_NODE), None, Some(&WORD_UNIF_NODE), - None, + Some(&WORD_UNIG_NODE), Some(&WORD_UNIH_NODE), None, None, @@ -3726,7 +7980,7 @@ static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_UNIL_NODE), Some(&WORD_UNIM_NODE), Some(&WORD_UNIN_NODE), - None, + Some(&WORD_UNIO_NODE), None, Some(&WORD_UNIQ_NODE), None, @@ -3748,45 +8002,61 @@ static WORD_UNIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"], ], range: 4..=9, }; @@ -3797,9 +8067,39 @@ static WORD_UNIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_UNIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("esstates")], - values: &[&["unitedstates"]], - range: 8..=8, + 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("ss"), + ], + values: &[ + &["uninterrupted"], + &["unitedstates"], + &["uninitialize"], + &["uninitialized"], + &["uninitialised"], + &["uninitialising"], + &["utilities"], + &["utility"], + &["uninitialized"], + &["uninitializing"], + &["utilities"], + &["utility"], + &["uninitialized"], + &["units"], + ], + range: 2..=9, }; static WORD_UNIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3824,91 +8124,262 @@ static WORD_UNIQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: 3..=7, + 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("s")], + values: &[&["unions"]], + range: 1..=1, }; static WORD_UNIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_UNIN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_UNIN_CHILDREN), value: None, }; -pub static WORD_UNIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("amous"), - dictgen::InsensitiveStr::Ascii("italised"), - dictgen::InsensitiveStr::Ascii("italizable"), - dictgen::InsensitiveStr::Ascii("italized"), - dictgen::InsensitiveStr::Ascii("sipred"), - dictgen::InsensitiveStr::Ascii("spiried"), - dictgen::InsensitiveStr::Ascii("spried"), - dictgen::InsensitiveStr::Ascii("staled"), - dictgen::InsensitiveStr::Ascii("staling"), - dictgen::InsensitiveStr::Ascii("stallimg"), - dictgen::InsensitiveStr::Ascii("stallled"), - dictgen::InsensitiveStr::Ascii("stallling"), - dictgen::InsensitiveStr::Ascii("stallng"), - dictgen::InsensitiveStr::Ascii("tellegent"), - dictgen::InsensitiveStr::Ascii("telligant"), - dictgen::InsensitiveStr::Ascii("telligient"), - dictgen::InsensitiveStr::Ascii("tensional"), - dictgen::InsensitiveStr::Ascii("tensionally"), - dictgen::InsensitiveStr::Ascii("tentinal"), - dictgen::InsensitiveStr::Ascii("tentionaly"), - dictgen::InsensitiveStr::Ascii("tentionnal"), - dictgen::InsensitiveStr::Ascii("tentionnally"), - dictgen::InsensitiveStr::Ascii("teresed"), - dictgen::InsensitiveStr::Ascii("teresing"), - dictgen::InsensitiveStr::Ascii("teristing"), - dictgen::InsensitiveStr::Ascii("terneted"), - dictgen::InsensitiveStr::Ascii("terruped"), - dictgen::InsensitiveStr::Ascii("terupted"), - dictgen::InsensitiveStr::Ascii("tuive"), + 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: &[ - &["unanimous"], + &["unintelligent"], + &["unintelligible"], + &["unintelligent"], + &["unintelligent"], + &["unintentional"], + &["unintentionally"], + &["unintended"], + &["unintentionally"], + &["unintentional"], + &["unintentionally"], + &["unintentional"], + &["unintentionally"], + &["uninterested"], + &["uninteresting"], + &["uninteresting"], + &["uninteresting"], + &["uninterested"], + &["uninterpreted"], + &["uninterrupted"], + &["uninterruptible"], + &["uninteresting"], + &["uninterrupted"], + &["uninterrupted"], + &["uninteresting"], + &["uninitialised"], + &["uninitialized"], + &["uninitialised"], + &["uninitialized"], &["uninitialised"], - &["uninitializable"], &["uninitialized"], - &["uninspired"], - &["uninspired"], - &["uninspired"], - &["uninstalled"], - &["uninstalling"], - &["uninstalling"], - &["uninstalled"], - &["uninstalling"], - &["uninstalling"], - &["unintelligent"], - &["unintelligent"], - &["unintelligent"], - &["unintentional"], - &["unintentionally"], - &["unintentional"], - &["unintentionally"], - &["unintentional"], - &["unintentionally"], - &["uninterested"], - &["uninteresting"], - &["uninteresting"], - &["uninterested"], - &["uninterrupted"], - &["uninterrupted"], &["unintuitive"], ], - range: 5..=12, + 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"), + ], + values: &[ + &["uninspired"], + &["uninspired"], + &["uninspired"], + &["uninstallable"], + &["uninstalled"], + &["uninstalling"], + &["uninstalling"], + &["uninstalled"], + &["uninstalling"], + &["uninstalling"], + &["uninstantiated"], + ], + range: 5..=8, +}; + +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 { @@ -3918,6 +8389,9 @@ static WORD_UNIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -3925,13 +8399,16 @@ pub static WORD_UNIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("presssed"), ], values: &[ + &["unimplemented"], + &["unimplemented"], + &["unimplemented"], &["unimportant"], &["unimportant"], &["unimpressed"], &["unimpressed"], &["unimpressed"], ], - range: 6..=8, + range: 6..=10, }; static WORD_UNIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -3970,6 +8447,17 @@ pub static WORD_UNIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -3977,12 +8465,42 @@ static WORD_UNIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_UNIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("iy"), dictgen::InsensitiveStr::Ascii("nished"), + 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: &[&["unfinished"], &["uniforms"], &["uniforms"]], - range: 4..=6, + values: &[ + &["unify"], + &["unfinished"], + &["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 { @@ -3992,6 +8510,7 @@ static WORD_UNIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("de"), dictgen::InsensitiveStr::Ascii("ornios"), dictgen::InsensitiveStr::Ascii("ornis"), dictgen::InsensitiveStr::Ascii("ornus"), @@ -3999,13 +8518,14 @@ pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("rons"), ], values: &[ + &["unicode"], &["unicorns"], &["unicorns"], &["unicorns"], &["unicorns"], &["unicorns"], ], - range: 3..=6, + range: 2..=6, }; static WORD_UNH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4015,22 +8535,30 @@ static WORD_UNH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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..=7, + range: 5..=8, }; static WORD_UNG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4040,6 +8568,7 @@ static WORD_UNG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_UNG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("eneralizeable"), dictgen::InsensitiveStr::Ascii("odley"), dictgen::InsensitiveStr::Ascii("oldy"), dictgen::InsensitiveStr::Ascii("rapeful"), @@ -4047,13 +8576,14 @@ pub static WORD_UNG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("reatfull"), ], values: &[ + &["ungeneralizable"], &["ungodly"], &["ungodly"], &["ungrateful"], &["ungrateful"], &["ungrateful"], ], - range: 4..=8, + range: 4..=13, }; static WORD_UNF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4069,31 +8599,50 @@ pub static WORD_UNF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("orunate"), + dictgen::InsensitiveStr::Ascii("orunately"), + dictgen::InsensitiveStr::Ascii("orutunate"), + dictgen::InsensitiveStr::Ascii("orutunately"), 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"], @@ -4102,94 +8651,391 @@ pub static WORD_UNF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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"], + &["unfortunate"], + &["unfortunately"], + &["unfortunate"], + &["unfortunately"], + &["unfortunately"], + &["unfortunately"], &["unfriendly"], &["unfriendly"], &["unfriendly"], &["unfriendly"], + &["unfortunately"], ], - range: 4..=11, + range: 3..=11, }; static WORD_UNE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_UNE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_UNE_CHILDREN), value: None, }; -pub static WORD_UNE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_UNE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + 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, + None, + 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("ccesary"), - dictgen::InsensitiveStr::Ascii("cessary"), - dictgen::InsensitiveStr::Ascii("dcuated"), - dictgen::InsensitiveStr::Ascii("dicated"), - dictgen::InsensitiveStr::Ascii("mployeed"), - dictgen::InsensitiveStr::Ascii("mployemnt"), - dictgen::InsensitiveStr::Ascii("mployent"), - dictgen::InsensitiveStr::Ascii("mploymed"), - dictgen::InsensitiveStr::Ascii("mplyoment"), - dictgen::InsensitiveStr::Ascii("mpolyed"), - dictgen::InsensitiveStr::Ascii("mpolyment"), - dictgen::InsensitiveStr::Ascii("nployment"), - dictgen::InsensitiveStr::Ascii("qualities"), - dictgen::InsensitiveStr::Ascii("xpectadely"), - dictgen::InsensitiveStr::Ascii("xpectadly"), - dictgen::InsensitiveStr::Ascii("xpectdly"), - dictgen::InsensitiveStr::Ascii("xpectely"), - dictgen::InsensitiveStr::Ascii("xpectetly"), - dictgen::InsensitiveStr::Ascii("xpectidly"), - dictgen::InsensitiveStr::Ascii("xperience"), - dictgen::InsensitiveStr::Ascii("xpextedly"), - dictgen::InsensitiveStr::Ascii("xplaind"), - dictgen::InsensitiveStr::Ascii("xplaned"), - dictgen::InsensitiveStr::Ascii("xplicably"), + 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: &[ - &["unnecessary"], - &["unnecessary"], - &["uneducated"], - &["uneducated"], - &["unemployed"], - &["unemployment"], - &["unemployment"], - &["unemployed"], - &["unemployment"], - &["unemployed"], - &["unemployment"], - &["unemployment"], - &["inequalities"], + &["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: 7..=10, + range: 4..=10, +}; + +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("forcable"), + dictgen::InsensitiveStr::Ascii("ployment"), + ], + values: &[ + &["unencrypt"], + &["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("essarily"), + dictgen::InsensitiveStr::Ascii("essary"), + ], + values: &[ + &["unnecessary"], + &["unnecessarily"], + &["unnecessarily"], + &["unnecessary"], + ], + range: 6..=9, }; static WORD_UND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4203,7 +9049,7 @@ static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_UNDE_NODE), - None, + Some(&WORD_UNDF_NODE), None, None, Some(&WORD_UNDI_NODE), @@ -4218,7 +9064,7 @@ static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_UNDR_NODE), None, None, - None, + Some(&WORD_UNDU_NODE), None, None, None, @@ -4226,6 +9072,17 @@ static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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("pplicated")], + values: &[&["unduplicated"]], + range: 9..=9, +}; + static WORD_UNDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_UNDR_CHILDREN), value: None, @@ -4245,6 +9102,9 @@ static WORD_UNDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ctrinated"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("rder"), + dictgen::InsensitiveStr::Ascii("rdered"), dictgen::InsensitiveStr::Ascii("ubedtly"), dictgen::InsensitiveStr::Ascii("ubetdly"), dictgen::InsensitiveStr::Ascii("ubtadly"), @@ -4257,6 +9117,9 @@ pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["indoctrinated"], + &["undo", "undone"], + &["unorder"], + &["unordered"], &["undoubtedly"], &["undoubtedly"], &["undoubtedly"], @@ -4267,7 +9130,7 @@ pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["undoubtedly"], &["undoubtedly"], ], - range: 6..=9, + range: 2..=9, }; static WORD_UNDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4276,9 +9139,27 @@ static WORD_UNDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_UNDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("serable")], - values: &[&["undesirable"]], - range: 7..=7, + 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 { @@ -4302,7 +9183,7 @@ static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_UNDEN_NODE), None, - None, + Some(&WORD_UNDEP_NODE), None, Some(&WORD_UNDER_NODE), Some(&WORD_UNDES_NODE), @@ -4317,13 +9198,23 @@ static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str static WORD_UNDET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_UNDET_CHILDREN), - value: None, + value: Some(&["under"]), }; pub static WORD_UNDET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ecable")], - values: &[&["undetectable"]], - range: 6..=6, + 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 { @@ -4338,6 +9229,8 @@ pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ireble"), dictgen::InsensitiveStr::Ascii("riable"), dictgen::InsensitiveStr::Ascii("rtand"), + dictgen::InsensitiveStr::Ascii("tand"), + dictgen::InsensitiveStr::Ascii("tood"), dictgen::InsensitiveStr::Ascii("tructible"), ], values: &[ @@ -4346,6 +9239,8 @@ pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["undesirable"], &["undesirable"], &["understands"], + &["understand"], + &["understood"], &["indestructible"], ], range: 4..=9, @@ -4368,7 +9263,7 @@ static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, None, None, - None, + Some(&WORD_UNDERL_NODE), Some(&WORD_UNDERM_NODE), Some(&WORD_UNDERN_NODE), Some(&WORD_UNDERO_NODE), @@ -4377,7 +9272,7 @@ static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st Some(&WORD_UNDERR_NODE), Some(&WORD_UNDERS_NODE), Some(&WORD_UNDERT_NODE), - None, + Some(&WORD_UNDERU_NODE), None, Some(&WORD_UNDERW_NODE), None, @@ -4441,6 +9336,20 @@ pub static WORD_UNDERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -4448,22 +9357,44 @@ static WORD_UNDERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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..=6, + range: 2..=7, }; static WORD_UNDERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4473,12 +9404,16 @@ static WORD_UNDERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -4490,15 +9425,20 @@ pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], @@ -4511,6 +9451,7 @@ pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["understands"], &["understands"], &["understood"], + &["understood"], &["understands"], &["understands"], ], @@ -4528,14 +9469,16 @@ pub static WORD_UNDERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("aker"), dictgen::InsensitiveStr::Ascii("ater"), dictgen::InsensitiveStr::Ascii("atted"), + dictgen::InsensitiveStr::Ascii("run"), ], values: &[ &["underrated"], &["undertaker"], &["undertaker"], &["underrated"], + &["underrun"], ], - range: 4..=5, + range: 3..=5, }; static WORD_UNDERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -4634,6 +9577,21 @@ pub static WORD_UNDERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("ow"), + ], + values: &[&["underlaid"], &["underlying"], &["underflow"]], + range: 2..=5, +}; + static WORD_UNDERH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_UNDERH_CHILDREN), value: None, @@ -4690,8 +9648,12 @@ static WORD_UNDERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_UNDERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("aker")], - values: &[&["undertaker"]], + keys: &[ + dictgen::InsensitiveStr::Ascii("aker"), + dictgen::InsensitiveStr::Ascii("iend"), + dictgen::InsensitiveStr::Ascii("ined"), + ], + values: &[&["undertaker"], &["undefined"], &["undefined"]], range: 4..=4, }; @@ -4786,6 +9748,17 @@ pub static WORD_UNDERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -4837,9 +9810,27 @@ static WORD_UNDEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_UNDEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("initely")], - values: &[&["indefinitely"]], - range: 7..=7, + 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 { @@ -4887,7 +9878,7 @@ static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_UNCO_NODE), None, None, - None, + Some(&WORD_UNCR_NODE), None, None, None, @@ -4898,102 +9889,185 @@ static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, ]; -static WORD_UNCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_UNCO_CHILDREN), +static WORD_UNCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_UNCR_CHILDREN), value: None, }; -pub static WORD_UNCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("mfertable"), - dictgen::InsensitiveStr::Ascii("mfertably"), - dictgen::InsensitiveStr::Ascii("mfortabel"), - dictgen::InsensitiveStr::Ascii("mfortablely"), - dictgen::InsensitiveStr::Ascii("mfortabley"), - dictgen::InsensitiveStr::Ascii("mfortablity"), - dictgen::InsensitiveStr::Ascii("mfortablly"), - dictgen::InsensitiveStr::Ascii("mforyable"), - dictgen::InsensitiveStr::Ascii("mfrotable"), - dictgen::InsensitiveStr::Ascii("mfrotably"), - dictgen::InsensitiveStr::Ascii("mftorable"), - dictgen::InsensitiveStr::Ascii("mftorably"), - dictgen::InsensitiveStr::Ascii("mited"), - dictgen::InsensitiveStr::Ascii("mitted"), - dictgen::InsensitiveStr::Ascii("mmited"), - dictgen::InsensitiveStr::Ascii("mpatible"), - dictgen::InsensitiveStr::Ascii("mpetive"), dictgen::InsensitiveStr::Ascii("ncious"), - dictgen::InsensitiveStr::Ascii("nciousness"), - dictgen::InsensitiveStr::Ascii("ncsious"), - dictgen::InsensitiveStr::Ascii("ncsiously"), - dictgen::InsensitiveStr::Ascii("nditinal"), - dictgen::InsensitiveStr::Ascii("nditionable"), - dictgen::InsensitiveStr::Ascii("nditionaly"), - dictgen::InsensitiveStr::Ascii("nditionnal"), - dictgen::InsensitiveStr::Ascii("nditionnally"), - dictgen::InsensitiveStr::Ascii("nfortability"), - dictgen::InsensitiveStr::Ascii("nfortable"), - dictgen::InsensitiveStr::Ascii("nfortably"), - dictgen::InsensitiveStr::Ascii("nsciosly"), - dictgen::InsensitiveStr::Ascii("nscioulsy"), - dictgen::InsensitiveStr::Ascii("nsciouly"), - dictgen::InsensitiveStr::Ascii("nsciouslly"), - dictgen::InsensitiveStr::Ascii("nscous"), - dictgen::InsensitiveStr::Ascii("nsicous"), - dictgen::InsensitiveStr::Ascii("nsicously"), - dictgen::InsensitiveStr::Ascii("nsiderate"), - dictgen::InsensitiveStr::Ascii("nsistent"), - dictgen::InsensitiveStr::Ascii("nstititional"), - dictgen::InsensitiveStr::Ascii("nstituional"), - dictgen::InsensitiveStr::Ascii("nstitutionnal"), - dictgen::InsensitiveStr::Ascii("ntitutional"), - dictgen::InsensitiveStr::Ascii("ntrallable"), - dictgen::InsensitiveStr::Ascii("ntrallably"), - dictgen::InsensitiveStr::Ascii("ntrolablly"), - dictgen::InsensitiveStr::Ascii("ntrollabe"), - dictgen::InsensitiveStr::Ascii("ntrollablely"), - dictgen::InsensitiveStr::Ascii("ntrollabley"), - dictgen::InsensitiveStr::Ascii("ntrollablly"), - dictgen::InsensitiveStr::Ascii("ntrollaby"), - dictgen::InsensitiveStr::Ascii("nvectional"), - dictgen::InsensitiveStr::Ascii("nvencional"), - dictgen::InsensitiveStr::Ascii("nvenient"), - dictgen::InsensitiveStr::Ascii("nvensional"), - dictgen::InsensitiveStr::Ascii("nvential"), - dictgen::InsensitiveStr::Ascii("nventianal"), - dictgen::InsensitiveStr::Ascii("nventinal"), - dictgen::InsensitiveStr::Ascii("nventionnal"), - dictgen::InsensitiveStr::Ascii("uncious"), - dictgen::InsensitiveStr::Ascii("unciously"), - dictgen::InsensitiveStr::Ascii("usciously"), + 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::Flat(&WORD_UNCON_CHILDREN), + value: None, +}; + +pub static WORD_UNCON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("cious"), + dictgen::InsensitiveStr::Ascii("ciousness"), + dictgen::InsensitiveStr::Ascii("cistencies"), + dictgen::InsensitiveStr::Ascii("cistency"), + dictgen::InsensitiveStr::Ascii("cistent"), + dictgen::InsensitiveStr::Ascii("csious"), + dictgen::InsensitiveStr::Ascii("csiously"), + dictgen::InsensitiveStr::Ascii("disional"), + dictgen::InsensitiveStr::Ascii("disionaly"), + dictgen::InsensitiveStr::Ascii("disionnal"), + dictgen::InsensitiveStr::Ascii("disionnaly"), + dictgen::InsensitiveStr::Ascii("ditinal"), + dictgen::InsensitiveStr::Ascii("ditinally"), + dictgen::InsensitiveStr::Ascii("ditionable"), + dictgen::InsensitiveStr::Ascii("ditionaly"), + dictgen::InsensitiveStr::Ascii("ditionnal"), + dictgen::InsensitiveStr::Ascii("ditionnally"), + dictgen::InsensitiveStr::Ascii("ditionnaly"), + dictgen::InsensitiveStr::Ascii("dtional"), + dictgen::InsensitiveStr::Ascii("dtionally"), + dictgen::InsensitiveStr::Ascii("figed"), + dictgen::InsensitiveStr::Ascii("fortability"), + dictgen::InsensitiveStr::Ascii("fortable"), + dictgen::InsensitiveStr::Ascii("fortably"), + dictgen::InsensitiveStr::Ascii("sciosly"), + dictgen::InsensitiveStr::Ascii("scioulsy"), + dictgen::InsensitiveStr::Ascii("sciouly"), + dictgen::InsensitiveStr::Ascii("sciouslly"), + dictgen::InsensitiveStr::Ascii("scous"), + dictgen::InsensitiveStr::Ascii("sicous"), + dictgen::InsensitiveStr::Ascii("sicously"), + dictgen::InsensitiveStr::Ascii("siderate"), + dictgen::InsensitiveStr::Ascii("sisntency"), + dictgen::InsensitiveStr::Ascii("sistent"), + dictgen::InsensitiveStr::Ascii("stititional"), + dictgen::InsensitiveStr::Ascii("stituional"), + dictgen::InsensitiveStr::Ascii("stitutionnal"), + dictgen::InsensitiveStr::Ascii("titutional"), + dictgen::InsensitiveStr::Ascii("trallable"), + dictgen::InsensitiveStr::Ascii("trallably"), + dictgen::InsensitiveStr::Ascii("trolable"), + dictgen::InsensitiveStr::Ascii("trolablly"), + dictgen::InsensitiveStr::Ascii("trollabe"), + dictgen::InsensitiveStr::Ascii("trollablely"), + dictgen::InsensitiveStr::Ascii("trollabley"), + dictgen::InsensitiveStr::Ascii("trollablly"), + dictgen::InsensitiveStr::Ascii("trollaby"), + dictgen::InsensitiveStr::Ascii("vectional"), + dictgen::InsensitiveStr::Ascii("vencional"), + dictgen::InsensitiveStr::Ascii("venient"), + dictgen::InsensitiveStr::Ascii("vensional"), + dictgen::InsensitiveStr::Ascii("vential"), + dictgen::InsensitiveStr::Ascii("ventianal"), + dictgen::InsensitiveStr::Ascii("ventinal"), + dictgen::InsensitiveStr::Ascii("ventionnal"), ], values: &[ - &["uncomfortable"], - &["uncomfortably"], - &["uncomfortably"], - &["uncomfortably"], - &["uncomfortably"], - &["uncomfortably"], - &["uncomfortably"], - &["uncomfortably"], - &["uncomfortable"], - &["uncomfortably"], - &["uncomfortable"], - &["uncomfortably"], - &["uncommitted"], - &["uncommitted"], - &["uncommitted"], - &["incompatible"], - &["uncompetitive"], &["unconscious"], &["unconsciousness"], + &["inconsistencies"], + &["inconsistency"], + &["inconsistent"], &["unconscious"], &["unconsciously"], &["unconditional"], + &["unconditionally"], + &["unconditional"], + &["unconditionally"], &["unconditional"], &["unconditionally"], &["unconditional"], &["unconditionally"], + &["unconditional"], + &["unconditionally"], + &["unconditionally"], + &["unconditional"], + &["unconditionally"], + &["unconfigured"], &["discomfort"], &["uncomfortable"], &["uncomfortably"], @@ -5005,6 +10079,7 @@ pub static WORD_UNCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["unconscious"], &["unconsciously"], &["inconsiderate"], + &["inconsistency"], &["inconsistent"], &["unconstitutional"], &["unconstitutional"], @@ -5012,6 +10087,7 @@ pub static WORD_UNCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["unconstitutional"], &["uncontrollable"], &["uncontrollably"], + &["uncontrollable"], &["uncontrollably"], &["uncontrollable"], &["uncontrollably"], @@ -5026,11 +10102,122 @@ pub static WORD_UNCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["unconventional"], &["unconventional"], &["unconventional"], - &["unconscious"], - &["unconsciously"], - &["unconsciously"], ], - range: 5..=13, + range: 5..=12, +}; + +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("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"], + &["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_UNCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5040,26 +10227,48 @@ static WORD_UNCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("eked"), + dictgen::InsensitiveStr::Ascii("enged"), ], - values: &[&["unchallengeable"], &["unchangeable"]], - range: 7..=10, + values: &[ + &["uncache"], + &["uncached"], + &["unchanged"], + &["unchanged"], + &["unchallengeable"], + &["unchanged"], + &["unchanged"], + &["unchangeable"], + &["unchecked"], + &["unchanged"], + ], + range: 4..=10, }; static WORD_UNCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_UNCE_CHILDREN), - value: None, + 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("rsored"), dictgen::InsensitiveStr::Ascii("rtaincy"), + dictgen::InsensitiveStr::Ascii("rtainities"), dictgen::InsensitiveStr::Ascii("rtainity"), dictgen::InsensitiveStr::Ascii("rtaintity"), dictgen::InsensitiveStr::Ascii("rtaintly"), @@ -5068,14 +10277,18 @@ pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("rtanty"), dictgen::InsensitiveStr::Ascii("rtianty"), dictgen::InsensitiveStr::Ascii("snored"), + dictgen::InsensitiveStr::Ascii("ssarily"), ], values: &[ + &["uncheck"], + &["unchecked"], &["uncensored"], &["uncensored"], &["uncensored"], &["uncensored"], &["uncensored"], &["uncertainty"], + &["uncertainties"], &["uncertainty"], &["uncertainty"], &["uncertainty"], @@ -5084,8 +10297,9 @@ pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["uncertainty"], &["uncertainty"], &["uncensored"], + &["unnecessarily"], ], - range: 5..=9, + range: 3..=10, }; static WORD_UNCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5095,11 +10309,19 @@ static WORD_UNCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["uncanny"], &["uncanny"], &["uncataloged"]], + values: &[ + &["unchanged"], + &["uncalculated"], + &["uncanny"], + &["uncanny"], + &["uncataloged"], + ], range: 4..=8, }; @@ -5125,20 +10347,35 @@ pub static WORD_UNB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -5147,6 +10384,7 @@ pub static WORD_UNB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("reakble"), dictgen::InsensitiveStr::Ascii("reakeble"), dictgen::InsensitiveStr::Ascii("rearable"), + dictgen::InsensitiveStr::Ascii("unded"), ], values: &[ &["unbalanced"], @@ -5165,19 +10403,34 @@ pub static WORD_UNB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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"], @@ -5186,8 +10439,9 @@ pub static WORD_UNB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unbreakable"], &["unbreakable"], &["unbreakable"], + &["unbundled", "unbounded"], ], - range: 4..=11, + range: 3..=11, }; static WORD_UNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5197,15 +10451,25 @@ static WORD_UNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_UNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("bailable"), + dictgen::InsensitiveStr::Ascii("bale"), dictgen::InsensitiveStr::Ascii("bel"), dictgen::InsensitiveStr::Ascii("bnned"), dictgen::InsensitiveStr::Ascii("ccaptable"), dictgen::InsensitiveStr::Ascii("cceptible"), + dictgen::InsensitiveStr::Ascii("ccesible"), dictgen::InsensitiveStr::Ascii("ccpetable"), + dictgen::InsensitiveStr::Ascii("cknowleged"), dictgen::InsensitiveStr::Ascii("companied"), dictgen::InsensitiveStr::Ascii("hppy"), + dictgen::InsensitiveStr::Ascii("lllowed"), + dictgen::InsensitiveStr::Ascii("mbigious"), + dictgen::InsensitiveStr::Ascii("mbigous"), + dictgen::InsensitiveStr::Ascii("mbigously"), + dictgen::InsensitiveStr::Ascii("med"), dictgen::InsensitiveStr::Ascii("minous"), dictgen::InsensitiveStr::Ascii("nimoulsy"), + dictgen::InsensitiveStr::Ascii("nimuous"), dictgen::InsensitiveStr::Ascii("nmious"), dictgen::InsensitiveStr::Ascii("nswerd"), dictgen::InsensitiveStr::Ascii("nwsered"), @@ -5215,33 +10479,59 @@ pub static WORD_UNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ppeeling"), dictgen::InsensitiveStr::Ascii("ppropriate"), dictgen::InsensitiveStr::Ascii("ppropriately"), + dictgen::InsensitiveStr::Ascii("quired"), + dictgen::InsensitiveStr::Ascii("rchving"), dictgen::InsensitiveStr::Ascii("snwered"), + dictgen::InsensitiveStr::Ascii("thenticated"), dictgen::InsensitiveStr::Ascii("thorised"), dictgen::InsensitiveStr::Ascii("ttanded"), + dictgen::InsensitiveStr::Ascii("tteded"), dictgen::InsensitiveStr::Ascii("ttendend"), dictgen::InsensitiveStr::Ascii("tteneded"), dictgen::InsensitiveStr::Ascii("ttented"), dictgen::InsensitiveStr::Ascii("ttracive"), dictgen::InsensitiveStr::Ascii("ttractice"), + dictgen::InsensitiveStr::Ascii("uthenicated"), dictgen::InsensitiveStr::Ascii("utherized"), dictgen::InsensitiveStr::Ascii("uthoried"), dictgen::InsensitiveStr::Ascii("uthroized"), + dictgen::InsensitiveStr::Ascii("vaiable"), + dictgen::InsensitiveStr::Ascii("vaialable"), + dictgen::InsensitiveStr::Ascii("vaialbale"), + dictgen::InsensitiveStr::Ascii("vaialbe"), + dictgen::InsensitiveStr::Ascii("vaialbel"), + dictgen::InsensitiveStr::Ascii("vaialbility"), + dictgen::InsensitiveStr::Ascii("vaialble"), + dictgen::InsensitiveStr::Ascii("vaible"), dictgen::InsensitiveStr::Ascii("vailabe"), + dictgen::InsensitiveStr::Ascii("vailabel"), dictgen::InsensitiveStr::Ascii("vailble"), dictgen::InsensitiveStr::Ascii("vailible"), dictgen::InsensitiveStr::Ascii("valiable"), + dictgen::InsensitiveStr::Ascii("vaoidable"), + dictgen::InsensitiveStr::Ascii("vilable"), dictgen::InsensitiveStr::Ascii("viodable"), dictgen::InsensitiveStr::Ascii("voidble"), dictgen::InsensitiveStr::Ascii("wnsered"), ], values: &[ + &["unavailable"], + &["unable"], &["unable"], &["unbanned"], &["unacceptable"], &["unacceptable"], + &["unaccessible"], &["unacceptable"], + &["unacknowledged"], &["unaccompanied"], &["unhappy"], + &["unallowed"], + &["unambiguous"], + &["unambiguous"], + &["unambiguously"], + &["unnamed"], + &["unanimous"], &["unanimous"], &["unanimous"], &["unanimous"], @@ -5253,14 +10543,19 @@ pub static WORD_UNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unappealing"], &["inappropriate"], &["inappropriately"], + &["unacquired"], + &["unarchiving"], &["unanswered"], + &["unauthenticated"], &["unauthorised"], &["unattended"], &["unattended"], &["unattended"], &["unattended"], + &["unattended"], &["unattractive"], &["unattractive"], + &["unauthenticated"], &["unauthorized"], &["unauthorized"], &["unauthorized"], @@ -5268,6 +10563,17 @@ pub static WORD_UNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["unavailable"], &["unavailable"], &["unavailable"], + &["unavailable"], + &["unavailability"], + &["unavailable"], + &["unavailable"], + &["unavailable"], + &["unavailable"], + &["unavailable"], + &["unavailable"], + &["unavailable"], + &["unavoidable"], + &["unavailable"], &["unavoidable"], &["unavoidable"], &["unanswered"], @@ -5282,26 +10588,42 @@ static WORD_UM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("mark"), + dictgen::InsensitiveStr::Ascii("outn"), dictgen::InsensitiveStr::Ascii("predictable"), ], values: &[ + &["unambiguous"], + &["unmark"], + &["unmarked"], &["unbelievable"], &["umbrella"], &["umbrella"], &["umbrella"], + &["umbrella"], &["uncomfortable"], &["uncomfortably"], &["unemployment"], + &["unimportant"], + &["unit"], + &["unmark"], + &["umount"], &["unpredictable"], ], - range: 5..=11, + range: 2..=11, }; static WORD_UL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5311,40 +10633,56 @@ static WORD_UL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_UL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[ + &["unlimited"], &["ultimate"], &["ultimately"], &["ultimatum"], &["ultimate"], + &["alter"], + &["alteration"], + &["alterations"], + &["altered"], + &["altering"], &["ulterior"], &["ulterior"], &["ulterior"], + &["alters"], &["ultimate"], &["ultimate"], &["ultimately"], &["ultimate"], &["ultimately"], + &["ultimately"], &["ultimatum"], &["ultimately"], &["ultrasound"], ], - range: 5..=9, + range: 3..=9, }; static WORD_UK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5355,6 +10693,9 @@ static WORD_UK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -5374,6 +10715,9 @@ pub static WORD_UK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg ], values: &[ &["ukraine"], + &["unknown"], + &["unknowns"], + &["unknowns", "unknown"], &["ukrainian"], &["ukrainians"], &["ukrainians"], @@ -5391,7 +10735,7 @@ pub static WORD_UK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["ukrainian"], &["ukrainians"], ], - range: 5..=9, + range: 4..=9, }; static WORD_UI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5400,9 +10744,14 @@ static WORD_UI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_UI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("se")], - values: &[&["use"]], - range: 2..=2, + keys: &[ + dictgen::InsensitiveStr::Ascii("que"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("te"), + dictgen::InsensitiveStr::Ascii("tes"), + ], + values: &[&["unique"], &["use"], &["suite"], &["suites"]], + range: 2..=3, }; static WORD_UG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5412,24 +10761,40 @@ static WORD_UG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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: &[&["upgrade"], &["upgraded"], &["upgrades"], &["upgrading"]], - range: 5..=7, + values: &[ + &["ugly"], + &["ugliness"], + &["ugliness"], + &["upgrade"], + &["upgraded"], + &["upgrades"], + &["upgrading"], + ], + range: 3..=7, }; static WORD_UE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_UE_CHILDREN), - value: None, + value: Some(&["use", "due"]), }; pub static WORD_UE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sfull")], - values: &[&["usefull"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ful"), + dictgen::InsensitiveStr::Ascii("gister"), + dictgen::InsensitiveStr::Ascii("sd"), + dictgen::InsensitiveStr::Ascii("sfull"), + ], + values: &[&["useful"], &["unregister"], &["used"], &["usefull"]], + range: 2..=6, }; static WORD_UD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5439,20 +10804,38 @@ static WORD_UD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_UD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ated"), + dictgen::InsensitiveStr::Ascii("ater"), + dictgen::InsensitiveStr::Ascii("ating"), dictgen::InsensitiveStr::Ascii("nercut"), dictgen::InsensitiveStr::Ascii("nerdog"), dictgen::InsensitiveStr::Ascii("nerestimate"), dictgen::InsensitiveStr::Ascii("nerpowered"), + dictgen::InsensitiveStr::Ascii("no"), + 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: &[ + &["updated", "dated"], + &["updater", "dater"], + &["updating", "dating"], &["undercut"], &["underdog"], &["underestimated"], &["underpowered"], + &["undo", "uno"], + &["updatable"], + &["update"], &["updated"], + &["updater"], + &["updates"], + &["updating"], ], - range: 5..=11, + range: 2..=11, }; static WORD_UB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5462,28 +10845,42 @@ static WORD_UB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("iqutious"), + dictgen::InsensitiveStr::Ascii("itquitous"), dictgen::InsensitiveStr::Ascii("lisher"), dictgen::InsensitiveStr::Ascii("subscribed"), dictgen::InsensitiveStr::Ascii("substantiated"), + dictgen::InsensitiveStr::Ascii("unut"), + dictgen::InsensitiveStr::Ascii("utunu"), ], values: &[ + &["unbelievable"], + &["unbelievably"], + &["kubernetes"], &["ubiquitous"], &["ubiquitous"], &["ubiquitous"], &["ubiquitous"], + &["ubiquitously"], + &["ubiquitous"], &["ubiquitous"], &["ubiquitous"], &["publisher"], &["unsubscribed"], &["unsubstantiated"], + &["ubuntu"], + &["ubuntu"], ], - range: 6..=13, + range: 4..=13, }; static WORD_T_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5493,8 +10890,8 @@ static WORD_T_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_TA_NODE), - None, - None, + Some(&WORD_TB_NODE), + Some(&WORD_TC_NODE), None, Some(&WORD_TE_NODE), None, @@ -5504,14 +10901,14 @@ static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_TJ_NODE), Some(&WORD_TK_NODE), Some(&WORD_TL_NODE), - None, + Some(&WORD_TM_NODE), None, Some(&WORD_TO_NODE), - None, + Some(&WORD_TP_NODE), None, Some(&WORD_TR_NODE), Some(&WORD_TS_NODE), - None, + Some(&WORD_TT_NODE), Some(&WORD_TU_NODE), None, Some(&WORD_TW_NODE), @@ -5527,38 +10924,84 @@ static WORD_TY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("es"), dictgen::InsensitiveStr::Ascii("hat"), dictgen::InsensitiveStr::Ascii("he"), + dictgen::InsensitiveStr::Ascii("ies"), dictgen::InsensitiveStr::Ascii("lenool"), + dictgen::InsensitiveStr::Ascii("mecode"), + 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("pechek"), + dictgen::InsensitiveStr::Ascii("pecheking"), + 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("ppe"), + dictgen::InsensitiveStr::Ascii("pped"), + dictgen::InsensitiveStr::Ascii("ppes"), 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"], + &["types", "ties"], &["that"], &["they"], + &["tries"], &["tylenol"], + &["timecode"], + &["type"], + &["typecast"], + &["typecasting"], + &["typecasts"], &["typical"], &["typically"], + &["typecheck"], + &["typechecking"], + &["typically", "typical"], &["typically"], + &["typically"], + &["typically"], + &["tuple"], + &["tuples"], + &["typo", "type", "types"], + &["typos", "types"], + &["typographic"], + &["type"], + &["typed"], + &["types"], &["tyrannies"], &["tyrannical"], &["tyrannical"], &["tyranny"], &["tryhard"], + &["trying"], &["tyrannies"], &["tyranny"], ], - range: 2..=8, + range: 1..=9, }; static WORD_TW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5568,17 +11011,21 @@ static WORD_TW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_TW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("po"), ], values: &[ + &["twelve"], &["twelfth"], &["twilight"], &["twilight"], &["town"], + &["two", "too"], &["two"], ], range: 2..=6, @@ -5593,59 +11040,107 @@ pub static WORD_TU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("esdsay"), dictgen::InsensitiveStr::Ascii("esdsy"), + dictgen::InsensitiveStr::Ascii("fure"), + dictgen::InsensitiveStr::Ascii("hmbnail"), + dictgen::InsensitiveStr::Ascii("nelled"), + dictgen::InsensitiveStr::Ascii("nelling"), + dictgen::InsensitiveStr::Ascii("nned"), + dictgen::InsensitiveStr::Ascii("nnell"), dictgen::InsensitiveStr::Ascii("nnells"), + dictgen::InsensitiveStr::Ascii("nning"), dictgen::InsensitiveStr::Ascii("nnles"), dictgen::InsensitiveStr::Ascii("nraround"), dictgen::InsensitiveStr::Ascii("nrtable"), + dictgen::InsensitiveStr::Ascii("otiral"), + dictgen::InsensitiveStr::Ascii("otirals"), + dictgen::InsensitiveStr::Ascii("pel"), dictgen::InsensitiveStr::Ascii("pparware"), dictgen::InsensitiveStr::Ascii("pperwears"), + dictgen::InsensitiveStr::Ascii("pple"), + dictgen::InsensitiveStr::Ascii("pples"), dictgen::InsensitiveStr::Ascii("rbins"), + dictgen::InsensitiveStr::Ascii("re"), dictgen::InsensitiveStr::Ascii("rkisch"), dictgen::InsensitiveStr::Ascii("rksih"), + dictgen::InsensitiveStr::Ascii("rle"), dictgen::InsensitiveStr::Ascii("rltes"), + dictgen::InsensitiveStr::Ascii("rly"), dictgen::InsensitiveStr::Ascii("rnapound"), dictgen::InsensitiveStr::Ascii("rnaroud"), + dictgen::InsensitiveStr::Ascii("rnk"), dictgen::InsensitiveStr::Ascii("rntabe"), dictgen::InsensitiveStr::Ascii("rntabel"), + dictgen::InsensitiveStr::Ascii("rorial"), + dictgen::InsensitiveStr::Ascii("rorials"), dictgen::InsensitiveStr::Ascii("rrest"), dictgen::InsensitiveStr::Ascii("rretts"), dictgen::InsensitiveStr::Ascii("rstworthy"), dictgen::InsensitiveStr::Ascii("rtels"), dictgen::InsensitiveStr::Ascii("rthfully"), + dictgen::InsensitiveStr::Ascii("rtorial"), + dictgen::InsensitiveStr::Ascii("rtorials"), + dictgen::InsensitiveStr::Ascii("scon"), dictgen::InsensitiveStr::Ascii("seday"), dictgen::InsensitiveStr::Ascii("sedays"), dictgen::InsensitiveStr::Ascii("snami"), dictgen::InsensitiveStr::Ascii("st"), + dictgen::InsensitiveStr::Ascii("tion"), dictgen::InsensitiveStr::Ascii("toriales"), + dictgen::InsensitiveStr::Ascii("toriel"), + dictgen::InsensitiveStr::Ascii("toriels"), dictgen::InsensitiveStr::Ascii("torual"), dictgen::InsensitiveStr::Ascii("trles"), ], values: &[ &["tuesdays"], &["tuesdays"], + &["future"], + &["thumbnail"], + &["tunnelled"], + &["tunnelling"], + &["tuned"], + &["tunnel"], &["tunnels"], + &["tuning", "running"], &["tunnels"], &["turnaround"], &["turntable"], + &["tutorial"], + &["tutorials"], + &["tuple"], &["tupperware"], &["tupperware"], + &["tuple"], + &["tuples"], &["turbines"], + &["true"], &["turkish"], &["turkish"], + &["turtle"], &["turtles"], + &["truly"], &["turnaround"], &["turnaround"], + &["trunk", "turnkey", "turn"], &["turntable"], &["turntable"], + &["tutorial"], + &["tutorials"], &["turrets"], &["turrets"], &["trustworthy"], &["turtles"], &["truthfully"], + &["tutorial"], + &["tutorials"], + &["tucson"], &["tuesday"], &["tuesdays"], &["tsunami"], &["trust"], + &["tuition"], + &["tutorials"], + &["tutorial"], &["tutorials"], &["tutorial"], &["turtles"], @@ -5653,6 +11148,20 @@ pub static WORD_TU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg range: 2..=9, }; +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("he"), + ], + values: &[&["tests"], &["the"]], + range: 2..=4, +}; + static WORD_TS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_TS_CHILDREN), value: None, @@ -5688,14 +11197,14 @@ static WORD_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_TRE_NODE), None, - None, + Some(&WORD_TRG_NODE), Some(&WORD_TRH_NODE), Some(&WORD_TRI_NODE), None, None, None, None, - None, + Some(&WORD_TRN_NODE), Some(&WORD_TRO_NODE), Some(&WORD_TRP_NODE), None, @@ -5720,9 +11229,23 @@ pub static WORD_TRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ahrd"), dictgen::InsensitiveStr::Ascii("annical"), dictgen::InsensitiveStr::Ascii("avon"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("ig"), + dictgen::InsensitiveStr::Ascii("inng"), + dictgen::InsensitiveStr::Ascii("s"), ], - values: &[&["tryhard"], &["tyrannical"], &["trayvon"]], - range: 4..=7, + values: &[ + &["tryhard"], + &["tyrannical"], + &["trayvon"], + &["tried"], + &["tries"], + &["trying"], + &["trying"], + &["tries"], + ], + range: 1..=7, }; static WORD_TRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5734,15 +11257,41 @@ pub static WORD_TRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("amatic"), dictgen::InsensitiveStr::Ascii("amatized"), + 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("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("dnle"), + dictgen::InsensitiveStr::Ascii("elly"), dictgen::InsensitiveStr::Ascii("ely"), + 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"), @@ -5751,22 +11300,50 @@ pub static WORD_TRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["trouble"], + &["troubled"], + &["troubles"], &["tribunal"], &["turbines"], + &["trouble"], + &["troubled"], + &["troubles"], + &["truncate"], + &["truncated"], + &["truncates"], + &["truncating"], + &["truncate"], + &["truncated"], + &["truncating"], &["trundle"], &["truly"], + &["truly"], + &["tried"], &["triumph"], &["turkish"], + &["truly"], &["tremendously"], + &["turn"], + &["truncated"], + &["truncate"], + &["truncate"], + &["truncated"], + &["truncating"], + &["truncation"], + &["truncated"], &["trundle"], + &["turned"], &["trundle"], + &["turns"], &["trustworthy"], &["trustworthy"], &["trustworthy"], @@ -5775,11 +11352,13 @@ pub static WORD_TRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["trustworthy"], &["trustworthiness"], &["trustworthy"], + &["trustworthiness"], &["trustworthy"], &["truthfully"], &["truthfully"], + &["true"], ], - range: 3..=12, + range: 1..=12, }; static WORD_TRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5809,6 +11388,7 @@ pub static WORD_TRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("pcial"), dictgen::InsensitiveStr::Ascii("pedo"), dictgen::InsensitiveStr::Ascii("tilla"), + dictgen::InsensitiveStr::Ascii("ttle"), dictgen::InsensitiveStr::Ascii("ubelshoot"), dictgen::InsensitiveStr::Ascii("ubelshooting"), dictgen::InsensitiveStr::Ascii("ubelsome"), @@ -5816,6 +11396,10 @@ pub static WORD_TRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ublehsooting"), dictgen::InsensitiveStr::Ascii("ubleshooot"), dictgen::InsensitiveStr::Ascii("ubleshotting"), + dictgen::InsensitiveStr::Ascii("ublshooting"), + dictgen::InsensitiveStr::Ascii("ughput"), + dictgen::InsensitiveStr::Ascii("ught"), + dictgen::InsensitiveStr::Ascii("up"), dictgen::InsensitiveStr::Ascii("ups"), ], values: &[ @@ -5828,6 +11412,7 @@ pub static WORD_TRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["tropical"], &["torpedo"], &["tortilla"], + &["throttle"], &["troubleshoot"], &["troubleshooting"], &["troublesome"], @@ -5835,92 +11420,338 @@ pub static WORD_TRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["troubleshooting"], &["troubleshoot"], &["troubleshooting"], - &["troupes"], + &["troubleshooting"], + &["throughput"], + &["through"], + &["troupe"], + &["troupes", "troops"], ], - range: 3..=12, + range: 2..=12, }; -static WORD_TRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_TRI_CHILDREN), +static WORD_TRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_TRN_CHILDREN), value: None, }; -pub static WORD_TRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_TRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aler"), - dictgen::InsensitiveStr::Ascii("alers"), - dictgen::InsensitiveStr::Ascii("aners"), - dictgen::InsensitiveStr::Ascii("ange"), - dictgen::InsensitiveStr::Ascii("angel"), - dictgen::InsensitiveStr::Ascii("angels"), - dictgen::InsensitiveStr::Ascii("angls"), - dictgen::InsensitiveStr::Ascii("aning"), - dictgen::InsensitiveStr::Ascii("anlge"), - dictgen::InsensitiveStr::Ascii("anlges"), - dictgen::InsensitiveStr::Ascii("anwreck"), - dictgen::InsensitiveStr::Ascii("ator"), - dictgen::InsensitiveStr::Ascii("ators"), - dictgen::InsensitiveStr::Ascii("buanl"), - dictgen::InsensitiveStr::Ascii("bunaal"), - dictgen::InsensitiveStr::Ascii("ckey"), - dictgen::InsensitiveStr::Ascii("ckyer"), - dictgen::InsensitiveStr::Ascii("dnet"), - dictgen::InsensitiveStr::Ascii("ggereing"), - dictgen::InsensitiveStr::Ascii("ggern"), - dictgen::InsensitiveStr::Ascii("ggerring"), - dictgen::InsensitiveStr::Ascii("guered"), - dictgen::InsensitiveStr::Ascii("logoy"), - dictgen::InsensitiveStr::Ascii("muph"), - dictgen::InsensitiveStr::Ascii("nagle"), - dictgen::InsensitiveStr::Ascii("nagles"), - dictgen::InsensitiveStr::Ascii("nekts"), - dictgen::InsensitiveStr::Ascii("ngale"), - dictgen::InsensitiveStr::Ascii("nitiy"), - dictgen::InsensitiveStr::Ascii("nkes"), - dictgen::InsensitiveStr::Ascii("nkst"), - dictgen::InsensitiveStr::Ascii("ntiy"), - dictgen::InsensitiveStr::Ascii("olgy"), - dictgen::InsensitiveStr::Ascii("ology"), - dictgen::InsensitiveStr::Ascii("umpth"), + 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, + None, + 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"), + ], + values: &[&["trivial"], &["trivially"], &["trivia"]], + 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("mpth")], + values: &[&["triumph"]], + range: 4..=4, +}; + +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("ple")], + values: &[&["triple"]], + range: 3..=3, +}; + +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("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"], + &["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("uph"), + ], + values: &[&["trimmed"], &["trimming", "timing"], &["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("ogoy")], + values: &[&["trilogy"]], + range: 4..=4, +}; + +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("gger"), + dictgen::InsensitiveStr::Ascii("uered"), + ], + values: &[ + &["trigger", "tiger"], + &["triggered"], + &["triggered"], + &["triggering"], + &["triggers"], + &["triggered"], + &["triggered"], + &["triggering"], + &["triggers"], + &["triggering"], + &["triggered"], + &["triggering"], + &["trigger"], + &["triggered"], + ], + range: 2..=7, +}; + +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("ncle"), + dictgen::InsensitiveStr::Ascii("ncles"), + 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("nwreck"), + dictgen::InsensitiveStr::Ascii("tor"), + dictgen::InsensitiveStr::Ascii("tors"), ], values: &[ &["trailer"], &["trailers"], + &["triangle"], + &["triangles"], &["trainers"], &["triangle"], &["triangle"], &["triangles"], &["triangles"], + &["triangular"], + &["triangulation"], + &["triangulation"], + &["triangulation"], &["training"], &["triangle"], &["triangles"], &["trainwreck"], &["traitor"], &["traitors"], - &["tribunal"], - &["tribunal"], - &["trickery"], - &["trickery"], - &["trident"], - &["triggering"], - &["triggering"], - &["triggering"], - &["triggered"], - &["trilogy"], - &["triumph"], - &["triangle"], - &["triangles"], - &["trinkets"], - &["triangle"], - &["trinity"], - &["trinkets"], - &["trinkets"], - &["trinity"], - &["trilogy"], - &["trilogy"], - &["triumph"], ], - range: 4..=8, + range: 3..=10, }; static WORD_TRH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -5930,25 +11761,43 @@ static WORD_TRH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_TRH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("e"), dictgen::InsensitiveStr::Ascii("illing"), dictgen::InsensitiveStr::Ascii("usters"), ], - values: &[&["thrilling"], &["thrusters"]], - range: 6..=6, + values: &[&["the"], &["thrilling"], &["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: None, + value: Some(&["tree"]), }; pub static WORD_TRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("adet"), + 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"), @@ -5967,18 +11816,29 @@ pub static WORD_TRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("ting"), ], values: &[ + &["treated"], + &["treat", "tweak"], &["treasure"], &["treasures"], &["treasury"], &["treasury"], &["treasures"], + &["treat"], + &["treatment"], + &["treatments"], + &["treats"], &["treaties"], &["treatments"], &["treatments"], @@ -5997,13 +11857,18 @@ pub static WORD_TRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["tremendous"], &["tremendous"], &["tremendously"], + &["trampoline"], &["trending"], + &["threshold"], + &["threshold"], &["trespassing"], &["trespassing"], + &["trestle"], &["trespassing"], &["treasury"], + &["treating"], ], - range: 4..=9, + range: 2..=9, }; static WORD_TRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6027,7 +11892,7 @@ static WORD_TRA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_TRAM_NODE), Some(&WORD_TRAN_NODE), None, - None, + Some(&WORD_TRAP_NODE), None, None, Some(&WORD_TRAS_NODE), @@ -6047,40 +11912,90 @@ static WORD_TRAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"], &["traverse"], - &["traverse"], - &["traverse"], + &["traversed"], + &["traverses"], + &["traversing"], &["travesty"], &["travesty"], &["travels"], ], - range: 3..=7, + range: 2..=7, }; static WORD_TRAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6113,43 +12028,121 @@ pub static WORD_TRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_TRAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_TRAS_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_TRAS_CHILDREN), value: None, }; -pub static WORD_TRAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ncript"), - dictgen::InsensitiveStr::Ascii("ncripts"), - dictgen::InsensitiveStr::Ascii("nfer"), - dictgen::InsensitiveStr::Ascii("nferred"), - dictgen::InsensitiveStr::Ascii("nferring"), - dictgen::InsensitiveStr::Ascii("nfers"), - dictgen::InsensitiveStr::Ascii("nform"), - dictgen::InsensitiveStr::Ascii("nformation"), - dictgen::InsensitiveStr::Ascii("nformed"), - dictgen::InsensitiveStr::Ascii("nformer"), - dictgen::InsensitiveStr::Ascii("nformers"), - dictgen::InsensitiveStr::Ascii("nforming"), - dictgen::InsensitiveStr::Ascii("nforms"), - dictgen::InsensitiveStr::Ascii("ngender"), - dictgen::InsensitiveStr::Ascii("ngendered"), - dictgen::InsensitiveStr::Ascii("nlated"), - dictgen::InsensitiveStr::Ascii("nlator"), - dictgen::InsensitiveStr::Ascii("nmission"), - dictgen::InsensitiveStr::Ascii("nmitted"), - dictgen::InsensitiveStr::Ascii("nmitter"), - dictgen::InsensitiveStr::Ascii("nparency"), - dictgen::InsensitiveStr::Ascii("nparent"), - dictgen::InsensitiveStr::Ascii("nphobic"), - dictgen::InsensitiveStr::Ascii("nplant"), - dictgen::InsensitiveStr::Ascii("nport"), - dictgen::InsensitiveStr::Ascii("nportation"), - dictgen::InsensitiveStr::Ascii("nported"), - dictgen::InsensitiveStr::Ascii("nporter"), - dictgen::InsensitiveStr::Ascii("nporting"), + 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("osition"), + dictgen::InsensitiveStr::Ascii("ositions"), ], values: &[ + &["transparency"], + &["transparent"], + &["transparently"], + &["transport"], + &["transportable"], + &["transported"], + &["transporter"], + &["transports"], + &["transpose"], + &["transposed"], + &["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("cript"), + dictgen::InsensitiveStr::Ascii("cripts"), + dictgen::InsensitiveStr::Ascii("fer"), + 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("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"], &["transcript"], &["transcripts"], &["transfer"], @@ -6165,7 +12158,10 @@ pub static WORD_TRAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["transforms"], &["transgender"], &["transgendered"], + &["translate"], &["translated"], + &["translation"], + &["translations"], &["translator"], &["transmissions"], &["transmitted"], @@ -6179,8 +12175,136 @@ pub static WORD_TRAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["transported"], &["transporter"], &["transporting"], + &["transports"], + &["transmit"], ], - range: 4..=10, + 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")], + values: &[&["transaction"]], + range: 5..=5, +}; + +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 { @@ -6189,7 +12313,7 @@ static WORD_TRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_TRANA_NODE), None, Some(&WORD_TRANC_NODE), Some(&WORD_TRAND_NODE), @@ -6210,7 +12334,7 @@ static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_TRANS_NODE), None, None, - None, + Some(&WORD_TRANV_NODE), None, None, None, @@ -6238,6 +12362,17 @@ pub static WORD_TRANZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("ersing")], + values: &[&["traversing"]], + range: 6..=6, +}; + static WORD_TRANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_TRANS_CHILDREN), value: None, @@ -6265,7 +12400,7 @@ static WORD_TRANS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st Some(&WORD_TRANSS_NODE), Some(&WORD_TRANST_NODE), Some(&WORD_TRANSU_NODE), - None, + Some(&WORD_TRANSV_NODE), None, None, Some(&WORD_TRANSY_NODE), @@ -6293,6 +12428,29 @@ pub static WORD_TRANSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -6310,9 +12468,25 @@ static WORD_TRANST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_TRANST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ator")], - values: &[&["translator"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ator"), + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("ions"), + dictgen::InsensitiveStr::Ascii("ition"), + dictgen::InsensitiveStr::Ascii("itions"), + dictgen::InsensitiveStr::Ascii("orm"), + dictgen::InsensitiveStr::Ascii("ormed"), + ], + values: &[ + &["translator"], + &["transition"], + &["transitions"], + &["transition"], + &["transitions"], + &["transform"], + &["transformed"], + ], + range: 3..=6, }; static WORD_TRANSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6322,6 +12496,7 @@ static WORD_TRANSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -6330,6 +12505,7 @@ pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("mision"), ], values: &[ + &["transcend"], &["transsexual"], &["transsexual"], &["transsexual"], @@ -6337,102 +12513,329 @@ pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transsexual"], &["transmissions"], ], - range: 4..=7, + range: 3..=7, }; static WORD_TRANSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_TRANSP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_TRANSP_CHILDREN), value: None, }; -pub static WORD_TRANSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[ - dictgen::InsensitiveStr::Ascii("alnt"), - dictgen::InsensitiveStr::Ascii("arancy"), - dictgen::InsensitiveStr::Ascii("arant"), - dictgen::InsensitiveStr::Ascii("arantie"), - dictgen::InsensitiveStr::Ascii("arecy"), - dictgen::InsensitiveStr::Ascii("arentcy"), - dictgen::InsensitiveStr::Ascii("arenty"), - dictgen::InsensitiveStr::Ascii("areny"), - dictgen::InsensitiveStr::Ascii("arrent"), - dictgen::InsensitiveStr::Ascii("erancy"), - dictgen::InsensitiveStr::Ascii("erant"), - dictgen::InsensitiveStr::Ascii("erency"), - dictgen::InsensitiveStr::Ascii("erent"), - dictgen::InsensitiveStr::Ascii("hoic"), - dictgen::InsensitiveStr::Ascii("honic"), - dictgen::InsensitiveStr::Ascii("hopic"), - dictgen::InsensitiveStr::Ascii("lain"), - dictgen::InsensitiveStr::Ascii("lanet"), - dictgen::InsensitiveStr::Ascii("lantees"), - dictgen::InsensitiveStr::Ascii("lantes"), - dictgen::InsensitiveStr::Ascii("lat"), - dictgen::InsensitiveStr::Ascii("late"), - dictgen::InsensitiveStr::Ascii("lats"), - dictgen::InsensitiveStr::Ascii("oder"), - dictgen::InsensitiveStr::Ascii("oration"), - dictgen::InsensitiveStr::Ascii("order"), - dictgen::InsensitiveStr::Ascii("oring"), - dictgen::InsensitiveStr::Ascii("ortaion"), - dictgen::InsensitiveStr::Ascii("ortar"), - dictgen::InsensitiveStr::Ascii("ortarme"), - dictgen::InsensitiveStr::Ascii("ortarse"), - dictgen::InsensitiveStr::Ascii("ortarte"), - dictgen::InsensitiveStr::Ascii("orteur"), - dictgen::InsensitiveStr::Ascii("orteurs"), - dictgen::InsensitiveStr::Ascii("ortion"), - dictgen::InsensitiveStr::Ascii("ortng"), - dictgen::InsensitiveStr::Ascii("ortor"), - dictgen::InsensitiveStr::Ascii("ortr"), - dictgen::InsensitiveStr::Ascii("ot"), - dictgen::InsensitiveStr::Ascii("otting"), - ], - values: &[ - &["transplants"], - &["transparency"], - &["transparent"], - &["transparent"], - &["transparency"], - &["transparency"], - &["transparency"], - &["transparency"], - &["transparent"], - &["transparency"], - &["transparent"], - &["transparency"], - &["transparent"], - &["transphobic"], - &["transphobic"], - &["transphobic"], - &["transplant"], - &["transplant"], - &["transplants"], - &["transplants"], - &["transplant"], - &["transplant"], - &["transplants"], - &["transported"], - &["transportation"], - &["transporter"], - &["transporting"], - &["transportation"], - &["transporter"], - &["transporter"], - &["transporter"], - &["transporter"], - &["transporter"], - &["transporter"], - &["transporting"], - &["transporting"], - &["transporter"], - &["transporter"], - &["transport"], - &["transporting"], - ], - range: 2..=7, +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, @@ -6440,22 +12843,56 @@ static WORD_TRANSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("frmed"), dictgen::InsensitiveStr::Ascii("frmers"), dictgen::InsensitiveStr::Ascii("frming"), 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"], &["transformed"], &["transformers"], &["transforming"], &["transphobic"], + &["translate"], + &["translated"], + &["translates"], + &["translating"], + &["translation"], + &["translations"], + &["transform"], + &["transformed"], + &["transforming"], + &["transforms"], ], - range: 3..=8, + range: 2..=8, }; static WORD_TRANSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6470,17 +12907,28 @@ pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -6492,23 +12940,34 @@ pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transmission"], &["transmission"], &["transmissions"], + &["transmissive"], &["transmissible"], &["transmissions"], &["transmission"], + &["transmission"], &["transmissions"], &["transmissions"], + &["transmit"], &["transmitted"], &["transmitter"], + &["transmitters"], + &["transmitting"], + &["transmission"], &["transmitter"], &["transistor"], - &["transmitter"], + &["transmission"], &["transmitted"], + &["transmission"], + &["transmitter"], + &["transmits"], + &["transmitted"], + &["transmit"], &["transformer"], &["transformed"], &["transforms"], &["transmitter"], ], - range: 4..=7, + range: 3..=7, }; static WORD_TRANSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6521,11 +12980,16 @@ pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -6536,18 +13000,23 @@ pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["translations"], &["translating"], &["translator"], + &["translators"], + &["translated"], &["translations"], &["translator"], &["translating"], &["translation"], + &["translations"], + &["translation"], &["transplants"], + &["transliteration"], &["translucent"], &["translucent"], &["translucent"], &["transylvania"], &["transylvania"], ], - range: 4..=7, + range: 4..=8, }; static WORD_TRANSK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6580,9 +13049,11 @@ pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("sioned"), dictgen::InsensitiveStr::Ascii("sioning"), dictgen::InsensitiveStr::Ascii("sions"), + dictgen::InsensitiveStr::Ascii("sition"), dictgen::InsensitiveStr::Ascii("sitor"), dictgen::InsensitiveStr::Ascii("ster"), dictgen::InsensitiveStr::Ascii("stion"), + dictgen::InsensitiveStr::Ascii("stions"), dictgen::InsensitiveStr::Ascii("stior"), dictgen::InsensitiveStr::Ascii("ten"), dictgen::InsensitiveStr::Ascii("tin"), @@ -6594,7 +13065,9 @@ pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("tionned"), dictgen::InsensitiveStr::Ascii("tionning"), dictgen::InsensitiveStr::Ascii("to"), + dictgen::InsensitiveStr::Ascii("ton"), dictgen::InsensitiveStr::Ascii("tons"), + dictgen::InsensitiveStr::Ascii("tor"), dictgen::InsensitiveStr::Ascii("tors"), ], values: &[ @@ -6607,9 +13080,11 @@ pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transitioned"], &["transitioning"], &["transitions"], + &["transition"], &["transistor"], &["transistor"], &["transition"], + &["transitions"], &["transistor"], &["transient"], &["transitions"], @@ -6621,8 +13096,10 @@ pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transitioned"], &["transitioning"], &["transition"], + &["transition"], &["transitions"], &["transistor"], + &["transistor", "transistors"], ], range: 2..=8, }; @@ -6688,14 +13165,23 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("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"), @@ -6704,7 +13190,10 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -6716,7 +13205,9 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -6735,13 +13226,22 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transfers"], &["transferring"], &["transferred"], + &["transferred"], &["transferring"], &["transfers"], &["transforms"], + &["transfer", "transferred"], &["transfers"], &["transform"], + &["transformation"], + &["transformational"], &["transformed"], + &["transformer"], &["transforms"], + &["transform"], + &["transformation"], + &["transformation"], + &["transformations"], &["transformed"], &["transformation"], &["transformers"], @@ -6750,8 +13250,11 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transformers"], &["transforms"], &["transforms"], + &["transformed"], + &["transforms"], &["transformation"], - &["transfer"], + &["transformed"], + &["transfer", "transformed", "transformer", "transform"], &["transforms"], &["transformed"], &["transformers"], @@ -6762,14 +13265,16 @@ pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transforms"], &["transforms"], &["transform"], + &["transform", "transformed"], &["transformation"], + &["transformations"], &["transformed"], - &["transformers"], + &["transformers", "transformer"], &["transformers"], &["transforming"], &["transforms"], ], - range: 2..=8, + range: 2..=9, }; static WORD_TRANSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6780,11 +13285,19 @@ static WORD_TRANSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"], &["transcending"], &["transsexuals"]], - range: 2..=6, + values: &[ + &["translates"], + &["transient"], + &["transcending"], + &["transfer"], + &["transsexuals"], + ], + range: 1..=6, }; static WORD_TRANSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6798,12 +13311,39 @@ pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("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"), @@ -6820,12 +13360,39 @@ pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["transcendence"], &["transcendent"], &["transcendental"], + &["transceiver"], + &["transceiver"], + &["transceivers"], &["transcripts"], &["transcripts"], &["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"], @@ -6848,7 +13415,14 @@ static WORD_TRANSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ccion"), + dictgen::InsensitiveStr::Ascii("cion"), dictgen::InsensitiveStr::Ascii("citon"), + dictgen::InsensitiveStr::Ascii("ctoin"), + 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"), @@ -6856,14 +13430,22 @@ pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], + &["transaction"], + &["translation", "transition", "transaction"], + &["translations", "transitions", "transactions"], + &["translation"], + &["translations"], + &["translate"], &["translate"], &["translated"], &["translates"], @@ -6871,12 +13453,13 @@ pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["translation"], &["translations"], &["translator"], + &["translators"], &["transparency"], - &["transition"], + &["transition", "transaction", "translation"], &["transitional"], - &["transitions"], + &["transitions", "transactions", "translations"], ], - range: 3..=6, + range: 2..=7, }; static WORD_TRANP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6885,9 +13468,19 @@ static WORD_TRANP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_TRANP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("shobic")], - values: &[&["transphobic"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("arent"), + dictgen::InsensitiveStr::Ascii("arently"), + dictgen::InsensitiveStr::Ascii("ort"), + dictgen::InsensitiveStr::Ascii("shobic"), + ], + values: &[ + &["transparent"], + &["transparently"], + &["transport"], + &["transphobic"], + ], + range: 3..=7, }; static WORD_TRANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6907,9 +13500,21 @@ static WORD_TRANM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_TRANM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sission")], - values: &[&["transmissions"]], - range: 7..=7, + 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 { @@ -6920,6 +13525,13 @@ static WORD_TRANL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -6928,6 +13540,13 @@ pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("uscent"), ], values: &[ + &["translations"], + &["translatable"], + &["translate"], + &["translated"], + &["translates"], + &["translating"], + &["translation"], &["translations"], &["translate"], &["translated"], @@ -6936,7 +13555,7 @@ pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["translations"], &["translucent"], ], - range: 4..=7, + range: 3..=7, }; static WORD_TRANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6946,6 +13565,7 @@ static WORD_TRANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ent"), dictgen::InsensitiveStr::Ascii("stion"), dictgen::InsensitiveStr::Ascii("stional"), dictgen::InsensitiveStr::Ascii("stioned"), @@ -6953,13 +13573,14 @@ pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("stions"), ], values: &[ + &["transient"], &["transition"], &["transitional"], &["transitioned"], &["transitioning"], &["transitions"], ], - range: 5..=8, + range: 3..=8, }; static WORD_TRANF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6969,11 +13590,36 @@ static WORD_TRANF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("orming"), + dictgen::InsensitiveStr::Ascii("orms"), ], - values: &[&["transform"], &["transformed"]], - range: 3..=5, + values: &[ + &["transfer"], + &["transferred"], + &["transferring"], + &["transferred"], + &["transfers"], + &["transform"], + &["transformable"], + &["transformation"], + &["transformations"], + &["transformative"], + &["transformed"], + &["transforming"], + &["transforms"], + ], + range: 2..=9, }; static WORD_TRAND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -6998,12 +13644,43 @@ static WORD_TRANC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["transcendent"], &["transcending"], &["translucent"]], - range: 6..=6, + 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("sction"), + ], + values: &[ + &["transaction"], + &["transactional"], + &["transactions"], + &["transaction"], + ], + range: 5..=7, }; static WORD_TRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7013,6 +13690,7 @@ static WORD_TRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("a"), dictgen::InsensitiveStr::Ascii("autic"), dictgen::InsensitiveStr::Ascii("autized"), dictgen::InsensitiveStr::Ascii("boline"), @@ -7021,9 +13699,12 @@ pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("polene"), dictgen::InsensitiveStr::Ascii("sformers"), dictgen::InsensitiveStr::Ascii("sforming"), + dictgen::InsensitiveStr::Ascii("smit"), + dictgen::InsensitiveStr::Ascii("smitted"), dictgen::InsensitiveStr::Ascii("uatized"), ], values: &[ + &["trauma"], &["traumatic"], &["traumatized"], &["trampoline"], @@ -7032,9 +13713,11 @@ pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["trampoline"], &["transformers"], &["transforming"], + &["transmit"], + &["transmitted"], &["traumatized"], ], - range: 5..=8, + range: 1..=8, }; static WORD_TRAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7046,8 +13729,9 @@ pub static WORD_TRAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ier"), dictgen::InsensitiveStr::Ascii("iers"), + dictgen::InsensitiveStr::Ascii("ing"), ], - values: &[&["trailer"], &["trailers"]], + values: &[&["trailer"], &["trailers"], &["trailing", "trialing"]], range: 3..=4, }; @@ -7057,9 +13741,13 @@ static WORD_TRAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_TRAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("cers")], - values: &[&["trackers"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("cers"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("ing"), + ], + values: &[&["trackers"], &["tracker"], &["tracking"]], + range: 2..=4, }; static WORD_TRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7069,11 +13757,20 @@ static WORD_TRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ing"), dictgen::InsensitiveStr::Ascii("leras"), dictgen::InsensitiveStr::Ascii("les"), + dictgen::InsensitiveStr::Ascii("lling"), dictgen::InsensitiveStr::Ascii("nes"), 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("nwreak"), dictgen::InsensitiveStr::Ascii("nwrek"), @@ -7082,11 +13779,20 @@ pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("tour"), ], values: &[ + &["trailing", "training"], &["trailers"], &["trailers"], + &["trailing"], &["trainers"], &["triangle"], &["triangles"], + &["triangular"], + &["triangulate"], + &["triangulated"], + &["triangulates"], + &["triangulating"], + &["triangulation"], + &["triangulations"], &["training"], &["trainwreck"], &["trainwreck"], @@ -7094,7 +13800,7 @@ pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["traitors"], &["traitor"], ], - range: 3..=6, + range: 3..=10, }; static WORD_TRAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7104,12 +13810,24 @@ static WORD_TRAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["targeted"], &["tragically"], &["tragically"]], - range: 4..=7, + values: &[ + &["trajectory"], + &["target"], + &["targeted"], + &["targeting"], + &["targets"], + &["tragically"], + &["tragically"], + ], + range: 2..=7, }; static WORD_TRAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7134,26 +13852,36 @@ static WORD_TRAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_TRAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[ + &["tragic"], &["traditional"], &["traditionally"], &["traditional"], + &["traditional"], + &["traditional"], &["traditionally"], &["traditional"], &["traditional"], + &["traditionally"], &["tradition"], + &["traditional"], &["traditionally"], ], - range: 7..=8, + range: 3..=10, }; static WORD_TRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7163,11 +13891,32 @@ static WORD_TRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["trackers"], &["trackers"]], - range: 3..=4, + 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 { @@ -7179,9 +13928,21 @@ pub static WORD_TRAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ajao"), dictgen::InsensitiveStr::Ascii("ajdo"), + dictgen::InsensitiveStr::Ascii("sform"), ], - values: &[&["trabajo"], &["trabajo"]], - range: 4..=4, + 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("yo")], + values: &[&["typo"]], + range: 2..=2, }; static WORD_TO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7190,11 +13951,11 @@ static WORD_TO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_TO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_TOA_NODE), Some(&WORD_TOB_NODE), Some(&WORD_TOC_NODE), Some(&WORD_TOD_NODE), - None, + Some(&WORD_TOE_NODE), None, Some(&WORD_TOG_NODE), None, @@ -7225,12 +13986,13 @@ static WORD_TOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["toxicity"], &["toxicity"], &["toxicity"]], - range: 5..=7, + values: &[&["toxin"], &["toxicity"], &["toxicity"], &["toxicity"]], + range: 2..=7, }; static WORD_TOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7254,16 +14016,23 @@ static WORD_TOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -7294,19 +14063,26 @@ pub static WORD_TOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["torch", "touch"], &["tourism"], &["tourists"], &["tourists"], @@ -7348,6 +14124,11 @@ pub static WORD_TOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("alitarion"), dictgen::InsensitiveStr::Ascii("alitarni"), dictgen::InsensitiveStr::Ascii("alitatian"), + dictgen::InsensitiveStr::Ascii("ation"), + 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"), @@ -7359,12 +14140,17 @@ pub static WORD_TOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["totalitarian"], &["totalitarian"], &["totalitarian"], + &["rotation"], + &["toshiba"], + &["total"], + &["tutorial"], + &["tutorials"], &["tottenham"], &["tottenham"], &["tottenham"], &["tutorials"], ], - range: 6..=9, + range: 2..=9, }; static WORD_TOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7381,10 +14167,12 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("nadoe"), dictgen::InsensitiveStr::Ascii("naodes"), dictgen::InsensitiveStr::Ascii("ndao"), @@ -7392,6 +14180,7 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -7403,6 +14192,7 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -7410,6 +14200,7 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -7417,6 +14208,8 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("unaments"), dictgen::InsensitiveStr::Ascii("uney"), dictgen::InsensitiveStr::Ascii("uneys"), + dictgen::InsensitiveStr::Ascii("ward"), + dictgen::InsensitiveStr::Ascii("wards"), ], values: &[ &["tornado"], @@ -7426,10 +14219,12 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["torchlight"], &["torchlight"], &["tolerable"], + &["tolerable"], &["torchlight"], &["toroidal"], &["tortilla"], &["tortillas"], + &["torque"], &["tornado"], &["tornadoes"], &["tornado"], @@ -7437,6 +14232,7 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["torpedo"], &["torpedoes"], &["torpedo"], + &["torpedoes"], &["trophies"], &["torrents"], &["torrenting"], @@ -7448,6 +14244,7 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["torrents"], &["tortillas"], &["tortilla"], + &["tortellini"], &["tortilla"], &["tortilla"], &["tortilla"], @@ -7455,6 +14252,7 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["tortilla"], &["tortilla"], &["tortoise"], + &["tortoise"], &["troubleshoot"], &["troublesome"], &["touristy"], @@ -7462,8 +14260,10 @@ pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["tournaments"], &["tourney"], &["tourneys"], + &["toward"], + &["towards"], ], - range: 4..=9, + range: 1..=9, }; static WORD_TOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7473,10 +14273,17 @@ static WORD_TOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_TOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("icaizer"), + dictgen::InsensitiveStr::Ascii("ologie"), dictgen::InsensitiveStr::Ascii("pingest"), dictgen::InsensitiveStr::Ascii("pins"), ], - values: &[&["toppings"], &["toppings"]], + values: &[ + &["topicalizer"], + &["topology"], + &["toppings"], + &["toppings"], + ], range: 4..=7, }; @@ -7488,17 +14295,37 @@ static WORD_TOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("lar"), + dictgen::InsensitiveStr::Ascii("lsbox"), + dictgen::InsensitiveStr::Ascii("m"), + dictgen::InsensitiveStr::Ascii("o"), + dictgen::InsensitiveStr::Ascii("s"), 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"], + &["toolbar"], + &["toolbox"], + &["tomb"], + &["todo"], + &["tools"], &["toothbrush"], &["toothbrush"], &["toothbrush"], &["toothbrush"], + &["teutonic"], ], range: 1..=7, }; @@ -7512,9 +14339,10 @@ pub static WORD_TON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("giht"), dictgen::InsensitiveStr::Ascii("guers"), + dictgen::InsensitiveStr::Ascii("ihgt"), dictgen::InsensitiveStr::Ascii("uges"), ], - values: &[&["tonight"], &["tongues"], &["tongues"]], + values: &[&["tonight"], &["tongues"], &["tonight"], &["tongues"]], range: 4..=5, }; @@ -7525,11 +14353,19 @@ static WORD_TOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], ], - values: &[&["tomatoes"], &["tomorrow"], &["tomorrow"]], range: 4..=6, }; @@ -7540,18 +14376,41 @@ static WORD_TOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_TOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("arable"), + 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("ernce"), dictgen::InsensitiveStr::Ascii("iets"), dictgen::InsensitiveStr::Ascii("kein"), + dictgen::InsensitiveStr::Ascii("lerable"), + dictgen::InsensitiveStr::Ascii("lerance"), + dictgen::InsensitiveStr::Ascii("lerances"), ], - values: &[&["tolerable"], &["tolerance"], &["toilets"], &["tolkien"]], - range: 4..=6, + values: &[ + &["tolerable"], + &["tolerance"], + &["token"], + &["tokens"], + &["tolerable"], + &["tolerance"], + &["tolerance"], + &["tolerance"], + &["toilets"], + &["tolkien"], + &["tolerable"], + &["tolerance"], + &["tolerances"], + ], + range: 2..=8, }; static WORD_TOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_TOI_CHILDREN), - value: None, + value: Some(&["to", "toy"]), }; pub static WORD_TOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -7568,11 +14427,36 @@ static WORD_TOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_TOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ehter"), + dictgen::InsensitiveStr::Ascii("gel"), dictgen::InsensitiveStr::Ascii("heter"), dictgen::InsensitiveStr::Ascii("hether"), + dictgen::InsensitiveStr::Ascii("ling"), + dictgen::InsensitiveStr::Ascii("lle"), + dictgen::InsensitiveStr::Ascii("lled"), + dictgen::InsensitiveStr::Ascii("ther"), ], - values: &[&["together"], &["together"], &["together"]], - range: 5..=6, + values: &[ + &["together"], + &["toggle"], + &["together"], + &["together"], + &["toggling"], + &["toggle"], + &["toggled"], + &["together"], + ], + range: 3..=6, +}; + +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")], + values: &[&["token"]], + range: 2..=2, }; static WORD_TOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7593,12 +14477,20 @@ static WORD_TOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["touchdown"], &["touchpad"], &["touchscreen"]], - range: 5..=8, + values: &[ + &["touches"], + &["toxin"], + &["touchdown"], + &["touchpad"], + &["touchscreen"], + ], + range: 3..=8, }; static WORD_TOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7607,9 +14499,34 @@ static WORD_TOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_TOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("baco")], - values: &[&["tobacco"]], - range: 4..=4, + 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_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 { @@ -7654,62 +14571,311 @@ pub static WORD_TJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg }; static WORD_TI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_TI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_TI_CHILDREN), value: None, }; -pub static WORD_TI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_TI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_TIA_NODE), + None, + Some(&WORD_TIC_NODE), + None, + Some(&WORD_TIE_NODE), + None, + Some(&WORD_TIG_NODE), + Some(&WORD_TIH_NODE), + None, + None, + None, + None, + 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, + None, + None, + None, + None, +]; + +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("awanese"), - dictgen::InsensitiveStr::Ascii("em"), - dictgen::InsensitiveStr::Ascii("ghetning"), - dictgen::InsensitiveStr::Ascii("ghtare"), - dictgen::InsensitiveStr::Ascii("ghtenting"), - dictgen::InsensitiveStr::Ascii("ghtining"), - dictgen::InsensitiveStr::Ascii("gthening"), - dictgen::InsensitiveStr::Ascii("gther"), - dictgen::InsensitiveStr::Ascii("hkn"), - dictgen::InsensitiveStr::Ascii("hs"), - dictgen::InsensitiveStr::Ascii("mestap"), - dictgen::InsensitiveStr::Ascii("mestmap"), - dictgen::InsensitiveStr::Ascii("mne"), - dictgen::InsensitiveStr::Ascii("ndergarten"), - dictgen::InsensitiveStr::Ascii("olets"), - dictgen::InsensitiveStr::Ascii("ome"), - dictgen::InsensitiveStr::Ascii("rangle"), - dictgen::InsensitiveStr::Ascii("rangles"), - dictgen::InsensitiveStr::Ascii("rbunal"), - dictgen::InsensitiveStr::Ascii("rdent"), - dictgen::InsensitiveStr::Ascii("tainum"), - dictgen::InsensitiveStr::Ascii("tanim"), - dictgen::InsensitiveStr::Ascii("tanuim"), + 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: &[ - &["taiwanese"], - &["time"], - &["tightening"], - &["tighter"], - &["tightening"], - &["tightening"], - &["tightening"], - &["tighter"], - &["think"], - &["this"], - &["timestamp"], - &["timestamp"], - &["time"], - &["kindergarten"], - &["toilets"], - &["time"], - &["triangle"], - &["triangles"], - &["tribunal"], - &["trident"], &["titanium"], &["titanium"], &["titanium"], + &["title"], + &["titles"], + &["title"], + &["titled"], + &["titling"], ], - range: 2..=10, + 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("edlta"), + dictgen::InsensitiveStr::Ascii("eing"), + dictgen::InsensitiveStr::Ascii("eot"), + dictgen::InsensitiveStr::Ascii("eput"), + dictgen::InsensitiveStr::Ascii("eputs"), + dictgen::InsensitiveStr::Ascii("ere"), + 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("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"], + &["timing"], + &["timeout"], + &["timeout"], + &["timeouts"], + &["timer"], + &["timespan"], + &["timespans"], + &["timespan"], + &["timestamp", "timespan"], + &["timestamps", "timespans"], + &["timespans"], + &["timestamp"], + &["timestamp"], + &["timestamps"], + &["timestamp"], + &["timestamps"], + &["timestamp"], + &["timestamps"], + &["timestamp"], + &["timestamps"], + &["timing", "trimming"], + &["time"], + &["timeout"], + &["timeout"], + &["timeout"], + &["timezone"], + &["timezones"], + &["timezone"], + &["timezones"], + ], + range: 2..=8, +}; + +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("s"), + ], + values: &[&["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("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"], + &["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("th"), + ], + values: &[ + &["tying"], + &["time", "item"], + &["timeout"], + &["timestamp"], + &["tithe"], + ], + range: 1..=6, +}; + +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"), + ], + values: &[ + &["thick", "tick", "titch", "stitch"], + &["thickened"], + &["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 { @@ -7720,27 +14886,27 @@ static WORD_TH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_TH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_THA_NODE), None, - None, + Some(&WORD_THC_NODE), None, Some(&WORD_THE_NODE), None, Some(&WORD_THG_NODE), None, Some(&WORD_THI_NODE), + Some(&WORD_THJ_NODE), None, None, - None, - None, + Some(&WORD_THM_NODE), Some(&WORD_THN_NODE), Some(&WORD_THO_NODE), None, - None, + Some(&WORD_THQ_NODE), Some(&WORD_THR_NODE), Some(&WORD_THS_NODE), Some(&WORD_THT_NODE), Some(&WORD_THU_NODE), None, - None, + Some(&WORD_THW_NODE), None, Some(&WORD_THY_NODE), None, @@ -7761,6 +14927,17 @@ pub static WORD_THY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -7770,10 +14947,12 @@ pub static WORD_THU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("bmnails"), dictgen::InsensitiveStr::Ascii("dnerbolt"), + dictgen::InsensitiveStr::Ascii("mbbnail"), dictgen::InsensitiveStr::Ascii("mbmails"), dictgen::InsensitiveStr::Ascii("mbnailers"), dictgen::InsensitiveStr::Ascii("mbnal"), dictgen::InsensitiveStr::Ascii("nberbolt"), + dictgen::InsensitiveStr::Ascii("ndebird"), dictgen::InsensitiveStr::Ascii("nderblot"), dictgen::InsensitiveStr::Ascii("nderboat"), dictgen::InsensitiveStr::Ascii("nderboldt"), @@ -7783,19 +14962,25 @@ pub static WORD_THU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nderjolt"), dictgen::InsensitiveStr::Ascii("nderolt"), dictgen::InsensitiveStr::Ascii("ndervolt"), + dictgen::InsensitiveStr::Ascii("r"), dictgen::InsensitiveStr::Ascii("rdsay"), dictgen::InsensitiveStr::Ascii("rdsays"), + dictgen::InsensitiveStr::Ascii("rough"), + dictgen::InsensitiveStr::Ascii("rrow"), dictgen::InsensitiveStr::Ascii("rsdsay"), dictgen::InsensitiveStr::Ascii("rsdsy"), dictgen::InsensitiveStr::Ascii("rsters"), + dictgen::InsensitiveStr::Ascii("rver"), ], values: &[ &["thumbnails"], &["thunderbolt"], + &["thumbnail"], &["thumbnails"], &["thumbnails"], &["thumbnails"], &["thunderbolt"], + &["thunderbird"], &["thunderbolt"], &["thunderbolt"], &["thunderbolt"], @@ -7805,125 +14990,326 @@ pub static WORD_THU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["thunderbolt"], &["thunderbolt"], &["thunderbolt"], + &["their"], &["thursday"], &["thursdays"], + &["thorough"], + &["thorough"], &["thursdays"], &["thursdays"], &["thrusters"], + &["further"], ], - range: 5..=9, + range: 1..=9, }; static WORD_THT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_THT_CHILDREN), - value: None, + value: Some(&["the", "that"]), }; pub static WORD_THT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("a")], - values: &[&["that"]], - range: 1..=1, + 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: None, + value: Some(&["the", "this"]), }; pub static WORD_THS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("es"), dictgen::InsensitiveStr::Ascii("i"), dictgen::InsensitiveStr::Ascii("oe"), + dictgen::InsensitiveStr::Ascii("ose"), + dictgen::InsensitiveStr::Ascii("ould"), + dictgen::InsensitiveStr::Ascii("t"), ], - values: &[&["this"], &["those"]], - range: 1..=2, + values: &[ + &["these"], + &["this"], + &["those"], + &["those"], + &["should"], + &["that"], + ], + range: 1..=4, }; static WORD_THR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_THR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_THR_CHILDREN), value: None, }; -pub static WORD_THR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("eadd"), - dictgen::InsensitiveStr::Ascii("eadened"), - dictgen::InsensitiveStr::Ascii("eataning"), - dictgen::InsensitiveStr::Ascii("eatend"), - dictgen::InsensitiveStr::Ascii("eatended"), - dictgen::InsensitiveStr::Ascii("eatenes"), - dictgen::InsensitiveStr::Ascii("eates"), - dictgen::InsensitiveStr::Ascii("eatining"), - dictgen::InsensitiveStr::Ascii("eatning"), - dictgen::InsensitiveStr::Ascii("eee"), - dictgen::InsensitiveStr::Ascii("eefor"), - dictgen::InsensitiveStr::Ascii("eeof"), - dictgen::InsensitiveStr::Ascii("eshhold"), - dictgen::InsensitiveStr::Ascii("id"), - dictgen::InsensitiveStr::Ascii("idly"), - dictgen::InsensitiveStr::Ascii("isty"), - dictgen::InsensitiveStr::Ascii("iteen"), - dictgen::InsensitiveStr::Ascii("ities"), - dictgen::InsensitiveStr::Ascii("oast"), - dictgen::InsensitiveStr::Ascii("oaths"), - dictgen::InsensitiveStr::Ascii("oium"), - dictgen::InsensitiveStr::Ascii("oners"), - dictgen::InsensitiveStr::Ascii("oough"), - dictgen::InsensitiveStr::Ascii("orough"), - dictgen::InsensitiveStr::Ascii("othling"), - dictgen::InsensitiveStr::Ascii("otlling"), - dictgen::InsensitiveStr::Ascii("ottleing"), - dictgen::InsensitiveStr::Ascii("oughiut"), - dictgen::InsensitiveStr::Ascii("oughly"), - dictgen::InsensitiveStr::Ascii("oughoput"), - dictgen::InsensitiveStr::Ascii("ought"), - dictgen::InsensitiveStr::Ascii("oughtout"), - dictgen::InsensitiveStr::Ascii("oughtput"), - dictgen::InsensitiveStr::Ascii("ougout"), - dictgen::InsensitiveStr::Ascii("usday"), - dictgen::InsensitiveStr::Ascii("usdays"), - dictgen::InsensitiveStr::Ascii("yoid"), + dictgen::InsensitiveStr::Ascii("e"), + 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"], + &["throughout"], + &["throughput"], + &["throughout"], + &["thursday"], + &["thursdays"], + ], + range: 1..=6, +}; + +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("ugt"), + dictgen::InsensitiveStr::Ascii("ugth"), + dictgen::InsensitiveStr::Ascii("uh"), + dictgen::InsensitiveStr::Ascii("uth"), + dictgen::InsensitiveStr::Ascii("wed"), + dictgen::InsensitiveStr::Ascii("wgh"), ], values: &[ - &["threaded"], - &["threaded"], - &["threatening"], - &["threatened"], - &["threatened"], - &["threatens"], - &["threatens"], - &["threatening"], - &["threatening"], - &["three"], - &["therefor"], - &["thereof"], - &["threshold"], - &["third"], - &["thirdly"], - &["thirsty"], - &["thirteen"], - &["thirties"], &["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"], + &["thought", "through", "throughout"], &["throughout"], &["throughput"], &["throughout"], - &["thursday"], - &["thursdays"], - &["thyroid"], + &["through"], + &["through"], + &["through"], + &["through"], + &["threw", "thrown"], + &["through"], ], - range: 2..=8, + 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("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("hold"), + dictgen::InsensitiveStr::Ascii("re"), + dictgen::InsensitiveStr::Ascii("refore"), + dictgen::InsensitiveStr::Ascii("shhold"), + dictgen::InsensitiveStr::Ascii("shholds"), + dictgen::InsensitiveStr::Ascii("shol"), + dictgen::InsensitiveStr::Ascii("sold"), + dictgen::InsensitiveStr::Ascii("sshold"), + ], + values: &[ + &["threaded"], + &["threaded"], + &["threadsafe"], + &["thread", "threat"], + &["threshold"], + &["thresholds"], + &["threatening"], + &["threatened"], + &["threatened"], + &["threatens"], + &["threatens"], + &["threatening"], + &["treatment"], + &["treatments"], + &["threatening"], + &["thread"], + &["threaded"], + &["threshold"], + &["threading"], + &["threads"], + &["three"], + &["therefor"], + &["thereof"], + &["threshold"], + &["there", "three"], + &["therefore"], + &["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 { @@ -7941,18 +15327,31 @@ pub static WORD_THO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("erist"), dictgen::InsensitiveStr::Ascii("erists"), dictgen::InsensitiveStr::Ascii("mspon"), + dictgen::InsensitiveStr::Ascii("nic"), dictgen::InsensitiveStr::Ascii("pmson"), dictgen::InsensitiveStr::Ascii("rats"), dictgen::InsensitiveStr::Ascii("rnes"), 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("ughout"), dictgen::InsensitiveStr::Ascii("ughs"), + dictgen::InsensitiveStr::Ascii("ugt"), + dictgen::InsensitiveStr::Ascii("ugth"), dictgen::InsensitiveStr::Ascii("ugths"), + dictgen::InsensitiveStr::Ascii("unsands"), dictgen::InsensitiveStr::Ascii("urogh"), dictgen::InsensitiveStr::Ascii("uroghly"), + dictgen::InsensitiveStr::Ascii("urough"), + dictgen::InsensitiveStr::Ascii("uroughly"), + dictgen::InsensitiveStr::Ascii("w"), + dictgen::InsensitiveStr::Ascii("wn"), ], values: &[ &["theocracy"], @@ -7963,20 +15362,33 @@ pub static WORD_THO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["theorist"], &["theorists"], &["thompson"], + &["chthonic"], &["thompson"], &["throats"], &["thrones"], &["thoroughly"], &["throttling"], + &["through", "thorough"], &["throughout"], &["thorium"], + &["thoroughly"], + &["thrown", "thorn"], + &["those", "this"], + &["those"], &["throughout"], &["thoughts"], + &["thought", "though"], + &["thought"], &["thoughts"], + &["thousands"], &["thorough"], &["thoroughly"], + &["thorough"], + &["thoroughly"], + &["throw", "tow"], + &["thrown", "town"], ], - range: 4..=10, + range: 1..=10, }; static WORD_THN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -7987,62 +15399,142 @@ static WORD_THN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["thankyou"], &["then"], &["thing"], &["things"]], + 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("ese")], + values: &[&["these"]], + range: 3..=3, +}; + static WORD_THI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_THI_CHILDREN), - value: None, + 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("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("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"), ], values: &[ &["thailand"], + &["thinking", "thickening"], + &["thickness", "thickens"], + &["this"], + &["the", "this"], &["their"], &["theistic"], &["theists"], + &["tight", "thigh", "fight"], + &["tights", "thighs", "fights"], &["thing"], &["things"], + &["thingy"], &["things"], + &["thick", "think"], &["think"], - &["thinking"], + &["thickness"], + &["thicknesses"], + &["thinking", "thickening"], &["thinks"], + &["thinks"], + &["time", "theme", "thyme", "thine"], + &["things"], + &["things"], + &["thinkable"], + &["think", "thing", "things"], + &["thinks", "things"], + &["thin"], &["thirties"], &["thirdly"], &["thrilling"], + &["third", "thirst"], &["thirsty"], &["thirteen"], &["thirteen"], &["thirsty"], + &["thirtieth"], + &["these", "this"], + &["thistle"], + &["this"], + &["this"], &["think"], ], - range: 2..=6, + range: 1..=7, }; static WORD_THG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -8070,7 +15562,7 @@ static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_THEE_NODE), - None, + Some(&WORD_THEF_NODE), None, None, Some(&WORD_THEI_NODE), @@ -8078,7 +15570,7 @@ static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_THEM_NODE), - None, + Some(&WORD_THEN_NODE), Some(&WORD_THEO_NODE), None, None, @@ -8086,41 +15578,92 @@ static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_THES_NODE), Some(&WORD_THET_NODE), None, + Some(&WORD_THEV_NODE), None, - None, - None, - 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")], - values: &[&["tethering"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ering"), + dictgen::InsensitiveStr::Ascii("her"), + dictgen::InsensitiveStr::Ascii("rahedron"), + ], + values: &[&["tethering"], &["tether", "whether"], &["tetrahedron"]], + range: 3..=8, }; static WORD_THES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_THES_CHILDREN), - value: None, + value: Some(&["this", "these"]), }; 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: &[&["theistic"], &["theists"]], - range: 3..=4, + 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::Flat(&WORD_THER_CHILDREN), - value: Some(&["there", "their", "the"]), + value: Some(&["there", "their", "the", "other"]), }; pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -8132,22 +15675,30 @@ pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("apeutisch"), dictgen::InsensitiveStr::Ascii("apeutuc"), dictgen::InsensitiveStr::Ascii("aphy"), + dictgen::InsensitiveStr::Ascii("apudic"), dictgen::InsensitiveStr::Ascii("apuetic"), dictgen::InsensitiveStr::Ascii("aupetic"), dictgen::InsensitiveStr::Ascii("by"), + dictgen::InsensitiveStr::Ascii("eads"), dictgen::InsensitiveStr::Ascii("eaputic"), dictgen::InsensitiveStr::Ascii("efo"), dictgen::InsensitiveStr::Ascii("efoer"), dictgen::InsensitiveStr::Ascii("efour"), dictgen::InsensitiveStr::Ascii("eian"), + dictgen::InsensitiveStr::Ascii("em"), + dictgen::InsensitiveStr::Ascii("eom"), dictgen::InsensitiveStr::Ascii("eotical"), dictgen::InsensitiveStr::Ascii("eotically"), dictgen::InsensitiveStr::Ascii("epeutic"), dictgen::InsensitiveStr::Ascii("epists"), + dictgen::InsensitiveStr::Ascii("erin"), + dictgen::InsensitiveStr::Ascii("fore"), dictgen::InsensitiveStr::Ascii("i"), dictgen::InsensitiveStr::Ascii("ien"), dictgen::InsensitiveStr::Ascii("ipists"), dictgen::InsensitiveStr::Ascii("mastat"), + dictgen::InsensitiveStr::Ascii("misor"), + dictgen::InsensitiveStr::Ascii("misors"), dictgen::InsensitiveStr::Ascii("mistat"), dictgen::InsensitiveStr::Ascii("modinamics"), dictgen::InsensitiveStr::Ascii("modyanmics"), @@ -8167,6 +15718,8 @@ pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("momter"), dictgen::InsensitiveStr::Ascii("moneter"), dictgen::InsensitiveStr::Ascii("mostaat"), + dictgen::InsensitiveStr::Ascii("mostast"), + dictgen::InsensitiveStr::Ascii("mostasts"), dictgen::InsensitiveStr::Ascii("nodynamics"), dictgen::InsensitiveStr::Ascii("oem"), dictgen::InsensitiveStr::Ascii("oetical"), @@ -8176,6 +15729,8 @@ pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("oists"), dictgen::InsensitiveStr::Ascii("omdynamics"), dictgen::InsensitiveStr::Ascii("omstat"), + dictgen::InsensitiveStr::Ascii("ough"), + dictgen::InsensitiveStr::Ascii("stat"), ], values: &[ &["thereafter"], @@ -8187,20 +15742,28 @@ pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["therapy"], &["therapeutic"], &["therapeutic"], + &["therapeutic"], &["thereby"], + &["threads"], &["therapeutic"], &["thereof"], &["therefor"], &["therefor"], &["therein"], + &["there", "theorem"], + &["theorem"], &["theoretical"], &["theoretically"], &["therapeutic"], &["therapists"], - &["their"], + &["therein"], + &["therefore"], + &["their", "there"], &["therein"], &["therapists"], &["thermostat"], + &["thermistor"], + &["thermistors"], &["thermostat"], &["thermodynamics"], &["thermodynamics"], @@ -8220,6 +15783,8 @@ pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["thermometer"], &["thermometer"], &["thermostat"], + &["thermostat"], + &["thermostats"], &["thermodynamics"], &["theorem"], &["theoretical"], @@ -8229,6 +15794,8 @@ pub static WORD_THER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["theorists"], &["thermodynamics"], &["thermostat"], + &["through", "thorough"], + &["thermostat"], ], range: 1..=10, }; @@ -8247,8 +15814,12 @@ pub static WORD_THEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -8261,15 +15832,33 @@ pub static WORD_THEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["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, @@ -8277,9 +15866,13 @@ static WORD_THEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_THEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"), @@ -8287,10 +15880,14 @@ pub static WORD_THEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("slves"), ], values: &[ + &["template"], &["themself"], &["themselves"], + &["themselves", "themself"], &["themselves"], &["themselves"], + &["themselves", "themself"], + &["themselves"], &["themselves"], &["themself"], &["themselves"], @@ -8301,29 +15898,60 @@ pub static WORD_THEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic static WORD_THEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_THEI_CHILDREN), - value: None, + 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"], &["theistic"], &["theistic"], &["thieves"]], + 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("se")], - values: &[&["these"]], - range: 2..=2, + 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 { @@ -8333,18 +15961,42 @@ static WORD_THEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["therapy"], &["theater"], &["theatre"], &["theatre"]], - range: 3..=4, + 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: None, + value: Some(&["than", "that", "the"]), }; pub static WORD_THA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -8356,8 +16008,15 @@ pub static WORD_THA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("re"), dictgen::InsensitiveStr::Ascii("st"), + dictgen::InsensitiveStr::Ascii("tn"), + dictgen::InsensitiveStr::Ascii("y"), ], values: &[ &["thailand"], @@ -8367,10 +16026,17 @@ pub static WORD_THA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["thankyou"], &["thankyou"], &["thankyou"], + &["than", "thank"], + &["thanks"], &["thanksgiving"], + &["transparent"], + &["than"], + &["there"], &["that"], + &["that", "than"], + &["they"], ], - range: 2..=9, + range: 1..=9, }; static WORD_TG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -8393,14 +16059,14 @@ static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_TEA_NODE), None, Some(&WORD_TEC_NODE), - None, + Some(&WORD_TED_NODE), Some(&WORD_TEE_NODE), - None, + Some(&WORD_TEF_NODE), None, Some(&WORD_TEH_NODE), None, None, - None, + Some(&WORD_TEK_NODE), Some(&WORD_TEL_NODE), Some(&WORD_TEM_NODE), Some(&WORD_TEN_NODE), @@ -8409,15 +16075,26 @@ static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_TEQ_NODE), Some(&WORD_TER_NODE), Some(&WORD_TES_NODE), - None, + Some(&WORD_TET_NODE), Some(&WORD_TEU_NODE), None, None, Some(&WORD_TEX_NODE), - None, + 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, @@ -8425,11 +16102,26 @@ static WORD_TEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("utres"), + dictgen::InsensitiveStr::Ascii("xt"), ], - values: &[&["textures"], &["textures"]], - range: 5..=6, + values: &[ + &["technically"], + &["textline"], + &["textframe"], + &["textures"], + &["textual"], + &["textually"], + &["textures"], + &["text"], + ], + range: 2..=9, }; static WORD_TEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -8446,6 +16138,29 @@ pub static WORD_TEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("rahedran"), + dictgen::InsensitiveStr::Ascii("rahedrans"), + dictgen::InsensitiveStr::Ascii("ry"), + dictgen::InsensitiveStr::Ascii("ss"), + dictgen::InsensitiveStr::Ascii("xture"), + ], + values: &[ + &["tetrahedron"], + &["tetrahedrons"], + &["retry"], + &["tests"], + &["texture"], + ], + range: 2..=9, +}; + static WORD_TES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_TES_CHILDREN), value: None, @@ -8453,11 +16168,31 @@ static WORD_TES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("itcle"), dictgen::InsensitiveStr::Ascii("itcles"), 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"), @@ -8467,14 +16202,36 @@ pub static WORD_TES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ticlular"), dictgen::InsensitiveStr::Ascii("tifiy"), dictgen::InsensitiveStr::Ascii("timoney"), + dictgen::InsensitiveStr::Ascii("tin"), + dictgen::InsensitiveStr::Ascii("tng"), dictgen::InsensitiveStr::Ascii("tomony"), ], values: &[ + &["testcase"], + &["testcases"], + &["these"], + &["used", "teased"], + &["tessellate"], + &["tessellated"], + &["tessellation"], + &["tessellator"], &["testicle"], &["testicles"], &["testify"], &["testimony"], + &["tessellate"], + &["tessellated"], + &["tessellated"], + &["tessellate"], + &["tessellated"], + &["tessellation"], + &["tessellator"], + &["tessellate"], + &["tessellated"], + &["tessellating"], + &["tessellator"], &["testosterone"], + &["testing"], &["testosterone"], &["testicle"], &["testicle"], @@ -8484,9 +16241,11 @@ pub static WORD_TES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["testicular"], &["testify"], &["testimony"], + &["testing"], + &["testing"], &["testimony"], ], - range: 4..=9, + range: 1..=9, }; static WORD_TER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -8503,12 +16262,12 @@ static WORD_TER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, - None, + Some(&WORD_TERI_NODE), None, None, None, Some(&WORD_TERM_NODE), - None, + Some(&WORD_TERN_NODE), Some(&WORD_TERO_NODE), None, None, @@ -8530,6 +16289,7 @@ static WORD_TERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -8571,6 +16331,7 @@ pub static WORD_TERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("urists"), ], values: &[ + &["terrible"], &["terabyte"], &["territorial"], &["territories"], @@ -8629,6 +16390,20 @@ pub static WORD_TERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), + ], + values: &[&["tournament"], &["terminate"]], + range: 5..=5, +}; + static WORD_TERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_TERM_CHILDREN), value: None, @@ -8641,6 +16416,7 @@ pub static WORD_TERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("endous"), dictgen::InsensitiveStr::Ascii("endously"), dictgen::InsensitiveStr::Ascii("ianls"), + dictgen::InsensitiveStr::Ascii("ianted"), dictgen::InsensitiveStr::Ascii("iantor"), dictgen::InsensitiveStr::Ascii("igator"), dictgen::InsensitiveStr::Ascii("inacion"), @@ -8652,12 +16428,31 @@ pub static WORD_TERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("inarlo"), dictgen::InsensitiveStr::Ascii("inaron"), 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("inilogy"), dictgen::InsensitiveStr::Ascii("inolgy"), dictgen::InsensitiveStr::Ascii("inoligy"), + dictgen::InsensitiveStr::Ascii("inte"), + dictgen::InsensitiveStr::Ascii("o"), + 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"], @@ -8665,6 +16460,7 @@ pub static WORD_TERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["tremendous"], &["tremendously"], &["terminals"], + &["terminated"], &["terminator"], &["terminator"], &["termination"], @@ -8676,14 +16472,48 @@ pub static WORD_TERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["terminal"], &["terminator"], &["terminator"], + &["terminators"], &["terminator"], &["termination"], &["termination"], + &["terminates"], + &["terminate"], + &["determine"], + &["terminated"], &["terminology"], &["terminology"], &["terminology"], + &["terminate"], + &["thermo"], + &["thermostat"], + &["temperature"], + &["temperatures"], + &["temperature"], + &["temperatures"], + &["template"], + &["templated"], + &["templates"], + &["temporal"], + &["temporaries"], + &["temporarily"], + &["temporary"], ], - range: 5..=8, + 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"), + ], + values: &[&["pterodactyl"], &["terrific"], &["terminate"]], + range: 3..=6, }; static WORD_TEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -8706,9 +16536,19 @@ static WORD_TEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_TEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("morarily")], - values: &[&["temporarily"]], - range: 8..=8, + 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 { @@ -8722,6 +16562,8 @@ pub static WORD_TEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("acle"), dictgen::InsensitiveStr::Ascii("acles"), dictgen::InsensitiveStr::Ascii("actiy"), + dictgen::InsensitiveStr::Ascii("ative"), + dictgen::InsensitiveStr::Ascii("atively"), dictgen::InsensitiveStr::Ascii("caity"), dictgen::InsensitiveStr::Ascii("dacy"), dictgen::InsensitiveStr::Ascii("dancies"), @@ -8741,12 +16583,15 @@ pub static WORD_TEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tacuel"), dictgen::InsensitiveStr::Ascii("talce"), dictgen::InsensitiveStr::Ascii("talces"), + dictgen::InsensitiveStr::Ascii("tion"), ], values: &[ &["tenacity"], &["tentacle"], &["tentacles"], &["tenacity"], + &["tentative"], + &["tentatively"], &["tenacity"], &["tendency"], &["tendencies"], @@ -8766,129 +16611,595 @@ pub static WORD_TEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["tentacle"], &["tentacle"], &["tentacles"], + &["tension"], ], range: 4..=9, }; static WORD_TEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_TEM_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_TEM_CHILDREN), value: None, }; -pub static WORD_TEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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_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: &[], + values: &[], + range: 0..=0, +}; + +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("afight"), - dictgen::InsensitiveStr::Ascii("afights"), - dictgen::InsensitiveStr::Ascii("eprature"), - dictgen::InsensitiveStr::Ascii("epratures"), - dictgen::InsensitiveStr::Ascii("epst"), - dictgen::InsensitiveStr::Ascii("erature"), - dictgen::InsensitiveStr::Ascii("palrs"), - dictgen::InsensitiveStr::Ascii("palte"), - dictgen::InsensitiveStr::Ascii("paltes"), - dictgen::InsensitiveStr::Ascii("parament"), - dictgen::InsensitiveStr::Ascii("parate"), - dictgen::InsensitiveStr::Ascii("parature"), - dictgen::InsensitiveStr::Ascii("paratures"), - dictgen::InsensitiveStr::Ascii("parement"), - dictgen::InsensitiveStr::Ascii("pearture"), - dictgen::InsensitiveStr::Ascii("pels"), - dictgen::InsensitiveStr::Ascii("peramant"), - dictgen::InsensitiveStr::Ascii("perarily"), - dictgen::InsensitiveStr::Ascii("peratue"), - dictgen::InsensitiveStr::Ascii("peratues"), - dictgen::InsensitiveStr::Ascii("peraturas"), - dictgen::InsensitiveStr::Ascii("peraturs"), - dictgen::InsensitiveStr::Ascii("peratuur"), - dictgen::InsensitiveStr::Ascii("perement"), - dictgen::InsensitiveStr::Ascii("permeant"), - dictgen::InsensitiveStr::Ascii("perment"), - dictgen::InsensitiveStr::Ascii("pertaure"), - dictgen::InsensitiveStr::Ascii("perture"), - dictgen::InsensitiveStr::Ascii("pets"), - dictgen::InsensitiveStr::Ascii("plaras"), - dictgen::InsensitiveStr::Ascii("plares"), - dictgen::InsensitiveStr::Ascii("plarios"), - dictgen::InsensitiveStr::Ascii("plarius"), - dictgen::InsensitiveStr::Ascii("plas"), - dictgen::InsensitiveStr::Ascii("plats"), - dictgen::InsensitiveStr::Ascii("pleos"), - dictgen::InsensitiveStr::Ascii("plers"), - dictgen::InsensitiveStr::Ascii("poraily"), - dictgen::InsensitiveStr::Ascii("porairly"), - dictgen::InsensitiveStr::Ascii("porali"), - dictgen::InsensitiveStr::Ascii("poraraly"), - dictgen::InsensitiveStr::Ascii("porarilly"), - dictgen::InsensitiveStr::Ascii("porarity"), - dictgen::InsensitiveStr::Ascii("porarly"), - dictgen::InsensitiveStr::Ascii("poray"), - dictgen::InsensitiveStr::Ascii("prary"), - dictgen::InsensitiveStr::Ascii("preature"), - dictgen::InsensitiveStr::Ascii("preatures"), - dictgen::InsensitiveStr::Ascii("proarily"), - dictgen::InsensitiveStr::Ascii("pset"), - dictgen::InsensitiveStr::Ascii("ptating"), - dictgen::InsensitiveStr::Ascii("ptetion"), - dictgen::InsensitiveStr::Ascii("purature"), - dictgen::InsensitiveStr::Ascii("puratures"), + 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: &[ - &["teamfight"], - &["teamfights"], + &["temporarily"], + &["temporal"], + &["temporarily"], + &["temporarily"], + &["temporary"], + &["temporary"], + &["temporarily"], + &["temporal"], + &["temperament"], + &["temperamental"], + &["temporarily"], + &["temporal"], + &["temporarily", "temporally"], + &["temporarily"], + &["temporarily"], + &["temporary"], + &["temporary"], + &["temporarily"], + &["temporary", "temporarily"], &["temperature"], &["temperatures"], - &["tempest"], + &["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("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"), + ], + values: &[ + &["template"], + &["templars"], + &["templars"], + &["templars"], + &["templars"], + &["templars"], + &["template"], + &["templates"], + &["templates"], + &["temples"], + &["temples"], + ], + 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("arure"), + dictgen::InsensitiveStr::Ascii("late"), + dictgen::InsensitiveStr::Ascii("ls"), + 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"], + &["template"], + &["temples"], + &["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("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"], &["temperament"], + &["temporarily"], + &["temporary"], &["temperate"], &["temperature"], &["temperatures"], &["temperament"], - &["temperatures"], - &["temples"], - &["temperament"], &["temporarily"], - &["temperature"], - &["temperatures"], - &["temperatures"], - &["temperatures"], - &["temperature"], - &["temperament"], - &["temperament"], - &["temperament"], - &["temperature"], - &["temperature"], - &["tempest"], - &["templars"], - &["templars"], - &["templars"], - &["templars"], - &["templars"], + &["template"], + &["templated"], &["templates"], - &["temples"], - &["temples"], - &["temporarily"], - &["temporarily"], - &["temporarily"], - &["temporarily"], - &["temporarily"], - &["temporarily"], - &["temporary"], - &["temporary"], - &["temporary"], - &["temperature"], - &["temperatures"], - &["temporarily"], - &["tempest"], - &["temptation"], + &["templatized"], &["temptation"], + &["templatised"], + &["templatized"], &["temperature"], - &["temperatures"], ], - range: 4..=9, + 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("nate"), + dictgen::InsensitiveStr::Ascii("nated"), + dictgen::InsensitiveStr::Ascii("nating"), + dictgen::InsensitiveStr::Ascii("nation"), + ], + values: &[ + &["terminate"], + &["terminated"], + &["terminating"], + &["termination"], + ], + range: 4..=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 { @@ -8900,6 +17211,7 @@ pub static WORD_TEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -8915,12 +17227,14 @@ pub static WORD_TEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -8936,10 +17250,25 @@ pub static WORD_TEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["television"], &["television"], &["teleportation"], + &["telecom"], &["teleportation"], &["telephony"], ], - range: 5..=10, + 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("st"), + dictgen::InsensitiveStr::Ascii("sts"), + ], + values: &[&["text"], &["texts"]], + range: 2..=3, }; static WORD_TEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -8958,6 +17287,17 @@ pub static WORD_TEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -8972,6 +17312,17 @@ pub static WORD_TEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=6, }; +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::Flat(&WORD_TEC_CHILDREN), value: None, @@ -8981,18 +17332,26 @@ pub static WORD_TEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("hanically"), dictgen::InsensitiveStr::Ascii("heis"), + dictgen::InsensitiveStr::Ascii("hical"), dictgen::InsensitiveStr::Ascii("hician"), dictgen::InsensitiveStr::Ascii("hicians"), + dictgen::InsensitiveStr::Ascii("hincal"), dictgen::InsensitiveStr::Ascii("hincality"), dictgen::InsensitiveStr::Ascii("hincally"), dictgen::InsensitiveStr::Ascii("hincian"), dictgen::InsensitiveStr::Ascii("hincians"), + dictgen::InsensitiveStr::Ascii("hinically"), dictgen::InsensitiveStr::Ascii("hinican"), + dictgen::InsensitiveStr::Ascii("hinique"), dictgen::InsensitiveStr::Ascii("hiniques"), dictgen::InsensitiveStr::Ascii("hinque"), dictgen::InsensitiveStr::Ascii("hinques"), + dictgen::InsensitiveStr::Ascii("hique"), + dictgen::InsensitiveStr::Ascii("hiques"), dictgen::InsensitiveStr::Ascii("hmological"), dictgen::InsensitiveStr::Ascii("hncially"), + dictgen::InsensitiveStr::Ascii("hneek"), + dictgen::InsensitiveStr::Ascii("hnic"), dictgen::InsensitiveStr::Ascii("hnicain"), dictgen::InsensitiveStr::Ascii("hnicallity"), dictgen::InsensitiveStr::Ascii("hnicalty"), @@ -9004,9 +17363,14 @@ pub static WORD_TEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("hnicien"), dictgen::InsensitiveStr::Ascii("hniciens"), dictgen::InsensitiveStr::Ascii("hnicion"), + dictgen::InsensitiveStr::Ascii("hnics"), + dictgen::InsensitiveStr::Ascii("hnik"), + dictgen::InsensitiveStr::Ascii("hniks"), dictgen::InsensitiveStr::Ascii("hniqe"), dictgen::InsensitiveStr::Ascii("hnitian"), dictgen::InsensitiveStr::Ascii("hnitians"), + dictgen::InsensitiveStr::Ascii("hnition"), + dictgen::InsensitiveStr::Ascii("hnlogy"), dictgen::InsensitiveStr::Ascii("hnnology"), dictgen::InsensitiveStr::Ascii("hnolgy"), dictgen::InsensitiveStr::Ascii("hnoligical"), @@ -9016,26 +17380,42 @@ pub static WORD_TEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("hnologicaly"), dictgen::InsensitiveStr::Ascii("hnologicially"), dictgen::InsensitiveStr::Ascii("hnologicly"), + dictgen::InsensitiveStr::Ascii("hnoloiges"), dictgen::InsensitiveStr::Ascii("hnqiues"), dictgen::InsensitiveStr::Ascii("honlogical"), dictgen::InsensitiveStr::Ascii("htician"), dictgen::InsensitiveStr::Ascii("hticians"), + dictgen::InsensitiveStr::Ascii("nic"), + dictgen::InsensitiveStr::Ascii("nical"), + dictgen::InsensitiveStr::Ascii("nically"), + dictgen::InsensitiveStr::Ascii("nician"), + dictgen::InsensitiveStr::Ascii("nicians"), + dictgen::InsensitiveStr::Ascii("nique"), + dictgen::InsensitiveStr::Ascii("niques"), ], values: &[ &["mechanically"], &["techies"], + &["technical"], &["technician"], &["technicians"], + &["technical"], &["technicality"], &["technically"], &["technician"], &["technicians"], + &["technically"], &["technician"], + &["technique"], + &["techniques"], + &["technique"], &["techniques"], &["technique"], &["techniques"], &["technological"], &["technically"], + &["technique"], + &["technique"], &["technician"], &["technically"], &["technicality"], @@ -9047,9 +17427,14 @@ pub static WORD_TEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["technician"], &["technicians"], &["technician"], + &["techniques"], + &["technique"], + &["techniques"], &["technique"], &["technician"], &["technicians"], + &["technician"], + &["technology"], &["technology"], &["technology"], &["technological"], @@ -9059,12 +17444,20 @@ pub static WORD_TEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["technologically"], &["technologically"], &["technological"], + &["technologies"], &["techniques"], &["technological"], &["technician"], &["technicians"], + &["technique"], + &["technical"], + &["technically"], + &["technician"], + &["technicians"], + &["technique"], + &["techniques"], ], - range: 4..=13, + range: 3..=13, }; static WORD_TEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -9075,6 +17468,7 @@ static WORD_TEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_TEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ched"), + dictgen::InsensitiveStr::Ascii("chnig"), dictgen::InsensitiveStr::Ascii("mfighs"), dictgen::InsensitiveStr::Ascii("mfighters"), dictgen::InsensitiveStr::Ascii("mfigt"), @@ -9082,6 +17476,8 @@ pub static WORD_TEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -9090,9 +17486,11 @@ pub static WORD_TEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("psoon"), dictgen::InsensitiveStr::Ascii("spon"), dictgen::InsensitiveStr::Ascii("spooon"), + dictgen::InsensitiveStr::Ascii("ted"), ], values: &[ &["taught"], + &["teaching"], &["teamfights"], &["teamfights"], &["teamfight"], @@ -9100,6 +17498,8 @@ pub static WORD_TEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["teamfights"], &["teamfight"], &["teamfights"], + &["template"], + &["templates"], &["teamspeak"], &["teamspeak"], &["teamspeak"], @@ -9108,141 +17508,559 @@ pub static WORD_TEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["teaspoon"], &["teaspoon"], &["teaspoon"], + &["treated"], ], - range: 4..=9, + range: 3..=9, }; -static WORD_TA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_TA_CHILDREN), +static WORD_TC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_TC_CHILDREN), value: None, }; -pub static WORD_TA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_TC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("bacco"), - dictgen::InsensitiveStr::Ascii("belspoon"), - dictgen::InsensitiveStr::Ascii("belspoons"), - dictgen::InsensitiveStr::Ascii("blepsoons"), - dictgen::InsensitiveStr::Ascii("blespon"), - dictgen::InsensitiveStr::Ascii("blespons"), - dictgen::InsensitiveStr::Ascii("blespooon"), - dictgen::InsensitiveStr::Ascii("blespooons"), - dictgen::InsensitiveStr::Ascii("blesppon"), - dictgen::InsensitiveStr::Ascii("blesppons"), - dictgen::InsensitiveStr::Ascii("citcally"), - dictgen::InsensitiveStr::Ascii("cticallity"), - dictgen::InsensitiveStr::Ascii("cticaly"), - dictgen::InsensitiveStr::Ascii("cticas"), - dictgen::InsensitiveStr::Ascii("cticts"), - dictgen::InsensitiveStr::Ascii("cticus"), - dictgen::InsensitiveStr::Ascii("gliate"), - dictgen::InsensitiveStr::Ascii("hn"), - dictgen::InsensitiveStr::Ascii("hnkyou"), - dictgen::InsensitiveStr::Ascii("ht"), - dictgen::InsensitiveStr::Ascii("ilban"), - dictgen::InsensitiveStr::Ascii("ilgateing"), - dictgen::InsensitiveStr::Ascii("ilgatting"), - dictgen::InsensitiveStr::Ascii("ilord"), - dictgen::InsensitiveStr::Ascii("ilsman"), - dictgen::InsensitiveStr::Ascii("iwanee"), - dictgen::InsensitiveStr::Ascii("iwanesse"), - dictgen::InsensitiveStr::Ascii("lbian"), - dictgen::InsensitiveStr::Ascii("lekd"), - dictgen::InsensitiveStr::Ascii("ligate"), - dictgen::InsensitiveStr::Ascii("ligating"), - dictgen::InsensitiveStr::Ascii("liored"), - dictgen::InsensitiveStr::Ascii("llents"), - dictgen::InsensitiveStr::Ascii("llets"), - dictgen::InsensitiveStr::Ascii("lsiman"), - dictgen::InsensitiveStr::Ascii("nenhill"), - dictgen::InsensitiveStr::Ascii("ngeld"), - dictgen::InsensitiveStr::Ascii("ngencially"), - dictgen::InsensitiveStr::Ascii("ngenitally"), - dictgen::InsensitiveStr::Ascii("ngentialy"), - dictgen::InsensitiveStr::Ascii("ngientally"), - dictgen::InsensitiveStr::Ascii("nlged"), - dictgen::InsensitiveStr::Ascii("nnheill"), - dictgen::InsensitiveStr::Ascii("ntrumers"), - dictgen::InsensitiveStr::Ascii("nturms"), - dictgen::InsensitiveStr::Ascii("pitude"), - dictgen::InsensitiveStr::Ascii("rgetd"), - dictgen::InsensitiveStr::Ascii("rgetted"), - dictgen::InsensitiveStr::Ascii("rgetting"), - dictgen::InsensitiveStr::Ascii("ryvon"), - dictgen::InsensitiveStr::Ascii("sliman"), - dictgen::InsensitiveStr::Ascii("st"), - dictgen::InsensitiveStr::Ascii("th"), - dictgen::InsensitiveStr::Ascii("too"), - dictgen::InsensitiveStr::Ascii("ttooes"), - dictgen::InsensitiveStr::Ascii("ttooos"), - dictgen::InsensitiveStr::Ascii("wainese"), - dictgen::InsensitiveStr::Ascii("wianese"), - dictgen::InsensitiveStr::Ascii("xanomic"), - dictgen::InsensitiveStr::Ascii("xanomy"), + dictgen::InsensitiveStr::Ascii("ahce"), + dictgen::InsensitiveStr::Ascii("ahces"), + dictgen::InsensitiveStr::Ascii("heckout"), + ], + values: &[&["cache"], &["caches"], &["checkout"]], + 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", "traveled"], + &["traveling", "traveling"], + &["travelled", "travelled"], + &["travelling", "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("h"), + dictgen::InsensitiveStr::Ascii("oo"), + dictgen::InsensitiveStr::Ascii("oos"), + dictgen::InsensitiveStr::Ascii("tooes"), + dictgen::InsensitiveStr::Ascii("tooos"), ], values: &[ - &["tobacco"], - &["tablespoon"], - &["tablespoons"], - &["tablespoons"], - &["tablespoon"], - &["tablespoons"], - &["tablespoon"], - &["tablespoon"], - &["tablespoon"], - &["tablespoons"], - &["tactically"], - &["tactically"], - &["tactically"], - &["tactics"], - &["tactics"], - &["tactics"], - &["tailgate"], - &["than"], - &["thankyou"], &["that"], - &["taliban"], - &["tailgating"], - &["tailgating"], - &["tailored"], - &["talisman"], - &["taiwanese"], - &["taiwanese"], + &["tattoo"], + &["tattoos"], + &["tattoos"], + &["tattoos"], + ], + range: 1..=5, +}; + +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"]], + 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("ged"), + dictgen::InsensitiveStr::Ascii("ger"), + 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("migan"), + dictgen::InsensitiveStr::Ascii("nsparent"), + dictgen::InsensitiveStr::Ascii("polin"), + dictgen::InsensitiveStr::Ascii("vis"), + dictgen::InsensitiveStr::Ascii("visci"), + dictgen::InsensitiveStr::Ascii("yvon"), + ], + values: &[ + &["tarball"], + &["tarballs"], + &["target"], + &["target"], + &["targeted"], + &["targeted"], + &["targeting"], + &["targeting"], + &["target"], + &["target"], + &["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("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("trumers"), + dictgen::InsensitiveStr::Ascii("turms"), + ], + values: &[ + &["tannehill"], + &["tangent"], + &["tangential"], + &["tangents"], + &["tangled"], + &["tangentially"], + &["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"], + &["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"], - &["tannehill"], - &["tangled"], - &["tangentially"], - &["tangentially"], - &["tangentially"], - &["tangentially"], - &["tangled"], - &["tannehill"], - &["tantrums"], - &["tantrums"], - &["aptitude"], - &["targeted"], - &["targeted"], - &["targeting"], - &["trayvon"], - &["talisman"], - &["taste"], - &["that"], - &["tattoo"], - &["tattoos"], - &["tattoos"], - &["taiwanese"], - &["taiwanese"], - &["taxonomic"], - &["taxonomy"], ], - range: 2..=10, + 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"], &["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("wanee"), + dictgen::InsensitiveStr::Ascii("wanesse"), + ], + values: &[ + &["taliban"], + &["tailgating"], + &["tailgating"], + &["tailored"], + &["talisman"], + &["taiwanese"], + &["taiwanese"], + ], + range: 4..=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("et"), + dictgen::InsensitiveStr::Ascii("ggen"), + dictgen::InsensitiveStr::Ascii("liate"), + dictgen::InsensitiveStr::Ascii("net"), + dictgen::InsensitiveStr::Ascii("netial"), + dictgen::InsensitiveStr::Ascii("nets"), + ], + values: &[ + &["stage", "take", "tag", "tagged"], + &["tagged"], + &["target"], + &["taggen"], + &["tailgate"], + &["tangent"], + &["tangential"], + &["tangents"], + ], + 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("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("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"], + &["tablespace"], + &["tablespaces"], + &["tablespoons"], + &["tablespoon"], + &["tablespoons"], + &["tablespoon"], + &["tablespoon"], + &["tablespoon"], + &["tablespoons"], + &["table"], + &["tabular"], + &["tabulate"], + &["tabulated"], + &["tabulates"], + &["tabulating"], + &["tabulate"], + &["tabulated"], + &["tabulates"], + &["tabulating"], + &["tabulator"], + &["tabulators"], + ], + range: 1..=9, }; static WORD_S_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -9252,12 +18070,12 @@ static WORD_S_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_SA_NODE), - None, + Some(&WORD_SB_NODE), Some(&WORD_SC_NODE), None, Some(&WORD_SE_NODE), - None, - None, + Some(&WORD_SF_NODE), + Some(&WORD_SG_NODE), Some(&WORD_SH_NODE), Some(&WORD_SI_NODE), None, @@ -9269,16 +18087,41 @@ static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_SP_NODE), Some(&WORD_SQ_NODE), Some(&WORD_SR_NODE), - None, + Some(&WORD_SS_NODE), Some(&WORD_ST_NODE), Some(&WORD_SU_NODE), - None, + Some(&WORD_SV_NODE), Some(&WORD_SW_NODE), - None, + Some(&WORD_SX_NODE), Some(&WORD_SY_NODE), - None, + 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, @@ -9286,7 +18129,7 @@ static WORD_SY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_SYA_NODE), - None, + Some(&WORD_SYB_NODE), Some(&WORD_SYC_NODE), Some(&WORD_SYD_NODE), None, @@ -9321,12 +18164,45 @@ static WORD_SYT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SYT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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"), ], - values: &[&["system"], &["style"], &["stylish"], &["styrofoam"]], - range: 2..=6, + values: &[ + &["system"], + &["systematic"], + &["systemd"], + &["system"], + &["systemerror"], + &["systemmemory"], + &["systems"], + &["systemwindow"], + &["synthesis"], + &["style"], + &["styled"], + &["styles"], + &["stylesheet"], + &["styling"], + &["stylish"], + &["syntax"], + &["syntax"], + &["styrofoam"], + ], + range: 2..=8, }; static WORD_SYS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -9338,9 +18214,18 @@ pub static WORD_SYS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tamatic"), + dictgen::InsensitiveStr::Ascii("tax"), + dictgen::InsensitiveStr::Ascii("te"), dictgen::InsensitiveStr::Ascii("tematicaly"), dictgen::InsensitiveStr::Ascii("tematiclly"), dictgen::InsensitiveStr::Ascii("tematisch"), @@ -9348,15 +18233,40 @@ pub static WORD_SYS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("temetic"), dictgen::InsensitiveStr::Ascii("temetically"), dictgen::InsensitiveStr::Ascii("temisch"), + dictgen::InsensitiveStr::Ascii("temwindiow"), + dictgen::InsensitiveStr::Ascii("ten"), + dictgen::InsensitiveStr::Ascii("tens"), + 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"], - &["systematically"], + &["system"], &["systematic"], + &["systems"], + &["systematically"], + &["symbol"], + &["seismograph"], + &["systematic"], + &["syntax"], + &["system"], &["systematically"], &["systematically"], &["systematic"], @@ -9364,10 +18274,26 @@ pub static WORD_SYS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["systematic"], &["systematically"], &["systemic"], + &["systemwindow"], + &["system"], + &["systems"], + &["system"], + &["systemerror"], + &["systemmemory"], + &["systems"], + &["systemwindow"], &["systematic"], &["systematically"], + &["system"], + &["system"], + &["systems"], + &["systems"], + &["system"], + &["systems"], + &["system"], + &["systems"], ], - range: 4..=11, + range: 2..=11, }; static WORD_SYR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -9413,6 +18339,7 @@ pub static WORD_SYP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("mtom"), dictgen::InsensitiveStr::Ascii("mtoms"), dictgen::InsensitiveStr::Ascii("nosis"), + dictgen::InsensitiveStr::Ascii("port"), ], values: &[ &["syphilis"], @@ -9422,181 +18349,435 @@ pub static WORD_SYP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["symptom"], &["symptoms"], &["synopsis"], + &["support"], ], range: 4..=8, }; static WORD_SYN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SYN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SYN_CHILDREN), value: None, }; -pub static WORD_SYN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("agouge"), - dictgen::InsensitiveStr::Ascii("chornously"), - dictgen::InsensitiveStr::Ascii("cronization"), - dictgen::InsensitiveStr::Ascii("cronous"), - dictgen::InsensitiveStr::Ascii("cronously"), - dictgen::InsensitiveStr::Ascii("dacite"), - dictgen::InsensitiveStr::Ascii("diacte"), - dictgen::InsensitiveStr::Ascii("egry"), - dictgen::InsensitiveStr::Ascii("idcate"), - dictgen::InsensitiveStr::Ascii("omymous"), - dictgen::InsensitiveStr::Ascii("omynous"), - dictgen::InsensitiveStr::Ascii("omyns"), - dictgen::InsensitiveStr::Ascii("onamous"), - dictgen::InsensitiveStr::Ascii("onimous"), - dictgen::InsensitiveStr::Ascii("onmyous"), - dictgen::InsensitiveStr::Ascii("onmys"), - dictgen::InsensitiveStr::Ascii("onomous"), - dictgen::InsensitiveStr::Ascii("onomy"), - dictgen::InsensitiveStr::Ascii("onumous"), - dictgen::InsensitiveStr::Ascii("onymes"), - dictgen::InsensitiveStr::Ascii("onymis"), - dictgen::InsensitiveStr::Ascii("onymns"), - dictgen::InsensitiveStr::Ascii("onymos"), - dictgen::InsensitiveStr::Ascii("onymus"), - dictgen::InsensitiveStr::Ascii("onynous"), - dictgen::InsensitiveStr::Ascii("opsies"), - dictgen::InsensitiveStr::Ascii("oynm"), - dictgen::InsensitiveStr::Ascii("oynms"), - dictgen::InsensitiveStr::Ascii("phony"), - dictgen::InsensitiveStr::Ascii("posis"), - dictgen::InsensitiveStr::Ascii("tehsis"), - dictgen::InsensitiveStr::Ascii("tehtic"), - dictgen::InsensitiveStr::Ascii("tethic"), - dictgen::InsensitiveStr::Ascii("thesasia"), - dictgen::InsensitiveStr::Ascii("thesesia"), + dictgen::InsensitiveStr::Ascii("ac"), + 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("axg"), + 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("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: &[ - &["synagogue"], - &["synchronously"], + &["syntax"], + &["syntax"], + &["syntax"], + &["syntax"], + &["syntactically"], + &["syntax"], + &["syntax"], + &["syntax"], + &["syntax"], + &["syntax"], + &["syntactic"], + &["syntax"], + &["synthesis"], + &["synthesise"], + &["synthesised"], + &["synthesize"], + &["synthesized"], + &["synthetic"], + &["synthesis"], + &["synthetic"], + &["synthetic"], + &["synthetize"], + &["synthetized"], + &["synthesis"], + &["synthesis"], + &["synthetic"], + &["synthetic"], + ], + range: 2..=7, +}; + +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("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"], + &["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"), + ], + values: &[&["syndicate"], &["syndicate"], &["syntonic"]], + range: 4..=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("honrous"), + 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"], &["synchronously"], - &["syndicate"], - &["syndicate"], - &["synergy"], - &["syndicate"], - &["synonymous"], - &["synonymous"], - &["synonyms"], - &["synonymous"], - &["synonymous"], - &["synonymous"], - &["synonyms"], - &["synonymous"], - &["synonym"], - &["synonymous"], - &["synonyms"], - &["synonyms"], - &["synonyms"], - &["synonymous"], - &["synonyms"], - &["synonymous"], - &["synopsis"], - &["synonym"], - &["synonyms"], - &["symphony"], - &["synopsis"], - &["synthesis"], - &["synthetic"], - &["synthetic"], - &["synthesis"], - &["synthesis"], + &["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..=11, + 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::Flat(&WORD_SYM_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SYM_CHILDREN), value: None, }; -pub static WORD_SYM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("apthetic"), - dictgen::InsensitiveStr::Ascii("apthize"), - dictgen::InsensitiveStr::Ascii("apthizers"), - dictgen::InsensitiveStr::Ascii("apthy"), - dictgen::InsensitiveStr::Ascii("boles"), - dictgen::InsensitiveStr::Ascii("bolisch"), - dictgen::InsensitiveStr::Ascii("bolisim"), - dictgen::InsensitiveStr::Ascii("bolsim"), - dictgen::InsensitiveStr::Ascii("etrical"), - dictgen::InsensitiveStr::Ascii("etrically"), - dictgen::InsensitiveStr::Ascii("etry"), - dictgen::InsensitiveStr::Ascii("ettric"), - dictgen::InsensitiveStr::Ascii("hpony"), - dictgen::InsensitiveStr::Ascii("mertical"), - dictgen::InsensitiveStr::Ascii("merty"), - dictgen::InsensitiveStr::Ascii("metral"), - dictgen::InsensitiveStr::Ascii("metria"), - dictgen::InsensitiveStr::Ascii("metricaly"), - dictgen::InsensitiveStr::Ascii("mety"), - dictgen::InsensitiveStr::Ascii("mtery"), - dictgen::InsensitiveStr::Ascii("oblic"), - dictgen::InsensitiveStr::Ascii("oblism"), - dictgen::InsensitiveStr::Ascii("obls"), - dictgen::InsensitiveStr::Ascii("pathatic"), - dictgen::InsensitiveStr::Ascii("patheic"), - dictgen::InsensitiveStr::Ascii("pathethic"), - dictgen::InsensitiveStr::Ascii("pathie"), - dictgen::InsensitiveStr::Ascii("pathiek"), - dictgen::InsensitiveStr::Ascii("pathien"), - dictgen::InsensitiveStr::Ascii("pathiers"), - dictgen::InsensitiveStr::Ascii("pathsize"), - dictgen::InsensitiveStr::Ascii("pathsizer"), - dictgen::InsensitiveStr::Ascii("pathtic"), - dictgen::InsensitiveStr::Ascii("pathyze"), - dictgen::InsensitiveStr::Ascii("pathyzers"), - dictgen::InsensitiveStr::Ascii("paty"), - dictgen::InsensitiveStr::Ascii("pethetic"), - dictgen::InsensitiveStr::Ascii("pethize"), - dictgen::InsensitiveStr::Ascii("pethizers"), - dictgen::InsensitiveStr::Ascii("phatetic"), - dictgen::InsensitiveStr::Ascii("phatize"), - dictgen::InsensitiveStr::Ascii("phatized"), - dictgen::InsensitiveStr::Ascii("phatizer"), - dictgen::InsensitiveStr::Ascii("phatizers"), - dictgen::InsensitiveStr::Ascii("phatizes"), - dictgen::InsensitiveStr::Ascii("phaty"), - dictgen::InsensitiveStr::Ascii("phoney"), - dictgen::InsensitiveStr::Ascii("phonity"), - dictgen::InsensitiveStr::Ascii("pithizers"), - dictgen::InsensitiveStr::Ascii("pothetic"), - dictgen::InsensitiveStr::Ascii("pothize"), - dictgen::InsensitiveStr::Ascii("ptomes"), - dictgen::InsensitiveStr::Ascii("ptomps"), - dictgen::InsensitiveStr::Ascii("ptoom"), - dictgen::InsensitiveStr::Ascii("tpom"), - dictgen::InsensitiveStr::Ascii("tpoms"), + 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"), ], values: &[ - &["sympathetic"], - &["sympathize"], - &["sympathizers"], - &["sympathy"], - &["symbols"], - &["symbolic"], - &["symbolism"], - &["symbolism"], - &["symmetrical"], - &["symmetrically"], - &["symmetry"], - &["symmetric"], - &["symphony"], - &["symmetrical"], - &["symmetry"], - &["symmetric"], - &["symmetrical"], - &["symmetrically"], - &["symmetry"], - &["symmetry"], - &["symbolic"], - &["symbolism"], - &["symbols"], &["sympathetic"], &["sympathetic"], &["sympathetic"], @@ -9628,10 +18809,172 @@ pub static WORD_SYM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["symptoms"], &["symptoms"], &["symptom"], - &["symptom"], - &["symptoms"], ], - range: 4..=9, + range: 3..=8, +}; + +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("blism"), + dictgen::InsensitiveStr::Ascii("bls"), + dictgen::InsensitiveStr::Ascii("l"), + dictgen::InsensitiveStr::Ascii("ls"), + ], + values: &[ + &["symbolic"], + &["symbol"], + &["symbolic"], + &["symbolism"], + &["symbols"], + &["symbol"], + &["symbols"], + ], + range: 1..=5, +}; + +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("lic"), + dictgen::InsensitiveStr::Ascii("o"), + dictgen::InsensitiveStr::Ascii("oles"), + dictgen::InsensitiveStr::Ascii("olisch"), + dictgen::InsensitiveStr::Ascii("olisim"), + dictgen::InsensitiveStr::Ascii("oll"), + dictgen::InsensitiveStr::Ascii("olsim"), + dictgen::InsensitiveStr::Ascii("sol"), + dictgen::InsensitiveStr::Ascii("sols"), + ], + values: &[ + &["symbolic"], + &["symbol"], + &["symbols"], + &["symbolic"], + &["symbolism"], + &["symbol"], + &["symbolism"], + &["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 { @@ -9643,18 +18986,36 @@ pub static WORD_SYL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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"], &["syllable"], &["syllable"], &["syllables"], + &["syllabus", "syllabification"], + &["syslog"], ], - range: 4..=6, + range: 1..=7, }; static WORD_SYK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -9703,11 +19064,98 @@ static WORD_SYC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SYC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[&["syncing"], &["scyther"]], - range: 4..=4, + values: &[ + &["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..=11, +}; + +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 { @@ -9717,75 +19165,215 @@ static WORD_SYA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], ], - values: &[&["syracuse"], &["says"]], range: 1..=5, }; -static WORD_SW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SW_CHILDREN), +static WORD_SX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SX_CHILDREN), value: None, }; -pub static WORD_SW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_SX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("l")], + values: &[&["xsl"]], + range: 1..=1, +}; + +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("aer"), - dictgen::InsensitiveStr::Ascii("aering"), - dictgen::InsensitiveStr::Ascii("aers"), - dictgen::InsensitiveStr::Ascii("aetshirt"), - dictgen::InsensitiveStr::Ascii("ansoon"), - dictgen::InsensitiveStr::Ascii("asitka"), - dictgen::InsensitiveStr::Ascii("askita"), - dictgen::InsensitiveStr::Ascii("astikka"), - dictgen::InsensitiveStr::Ascii("atiska"), - dictgen::InsensitiveStr::Ascii("atsika"), - dictgen::InsensitiveStr::Ascii("earengin"), - dictgen::InsensitiveStr::Ascii("earshirt"), - dictgen::InsensitiveStr::Ascii("eathsirt"), - dictgen::InsensitiveStr::Ascii("eatshit"), - dictgen::InsensitiveStr::Ascii("eatshits"), - dictgen::InsensitiveStr::Ascii("eatshort"), - dictgen::InsensitiveStr::Ascii("eatshrit"), - dictgen::InsensitiveStr::Ascii("edisch"), - dictgen::InsensitiveStr::Ascii("eerheart"), - dictgen::InsensitiveStr::Ascii("eetheat"), - dictgen::InsensitiveStr::Ascii("eetshart"), - dictgen::InsensitiveStr::Ascii("eidsh"), - dictgen::InsensitiveStr::Ascii("epth"), - dictgen::InsensitiveStr::Ascii("iflty"), - dictgen::InsensitiveStr::Ascii("iftley"), - dictgen::InsensitiveStr::Ascii("iming"), - dictgen::InsensitiveStr::Ascii("itcheasy"), - dictgen::InsensitiveStr::Ascii("itchign"), - dictgen::InsensitiveStr::Ascii("itchs"), - dictgen::InsensitiveStr::Ascii("iterzland"), - dictgen::InsensitiveStr::Ascii("itfly"), - dictgen::InsensitiveStr::Ascii("ithced"), - dictgen::InsensitiveStr::Ascii("ithces"), - dictgen::InsensitiveStr::Ascii("ithcing"), - dictgen::InsensitiveStr::Ascii("itserland"), - dictgen::InsensitiveStr::Ascii("itzerand"), - dictgen::InsensitiveStr::Ascii("itzlerand"), - dictgen::InsensitiveStr::Ascii("izterland"), - dictgen::InsensitiveStr::Ascii("nasea"), - dictgen::InsensitiveStr::Ascii("tiched"), - dictgen::InsensitiveStr::Ascii("tiches"), - dictgen::InsensitiveStr::Ascii("tiching"), - dictgen::InsensitiveStr::Ascii("tizerland"), + dictgen::InsensitiveStr::Ascii("ich"), + dictgen::InsensitiveStr::Ascii("iched"), + dictgen::InsensitiveStr::Ascii("iches"), + dictgen::InsensitiveStr::Ascii("iching"), + dictgen::InsensitiveStr::Ascii("ichs"), + dictgen::InsensitiveStr::Ascii("izerland"), + ], + values: &[ + &["switch"], + &["switched"], + &["switches"], + &["switching"], + &["switches"], + &["switzerland"], + ], + range: 3..=8, +}; + +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("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("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"], + &["switching"], + &["switzerland"], + &["swiftly"], + &["switch"], + &["switchable"], + &["switch"], + &["switchboard"], + &["switched"], + &["switches"], + &["switch"], + &["switches"], + &["switching"], + &["switching"], + &["switchover"], + &["switched"], + &["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: &[ - &["swear"], - &["swearing"], - &["swears"], - &["sweatshirt"], - &["swanson"], - &["swastika"], - &["swastika"], - &["swastika"], - &["swastika"], - &["swastika"], &["swearing"], &["sweatshirt"], &["sweatshirt"], @@ -9799,28 +19387,76 @@ pub static WORD_SW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["sweetheart"], &["swedish"], &["swept"], - &["swiftly"], - &["swiftly"], - &["swimming"], - &["switches"], - &["switching"], - &["switches"], - &["switzerland"], - &["swiftly"], - &["switched"], - &["switches"], - &["switching"], - &["switzerland"], - &["switzerland"], - &["switzerland"], - &["switzerland"], - &["swansea"], - &["switched"], - &["switches"], - &["switching"], - &["switzerland"], ], - range: 3..=9, + 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 { @@ -9836,8 +19472,8 @@ static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SUE_NODE), Some(&WORD_SUF_NODE), Some(&WORD_SUG_NODE), - None, - None, + Some(&WORD_SUH_NODE), + Some(&WORD_SUI_NODE), None, None, None, @@ -9848,126 +19484,363 @@ static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_SUR_NODE), Some(&WORD_SUS_NODE), + Some(&WORD_SUT_NODE), + Some(&WORD_SUU_NODE), + Some(&WORD_SUV_NODE), None, None, None, None, +]; + +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")], + values: &[&["souvenir"]], + range: 5..=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_SUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SUS_CHILDREN), +static WORD_SUSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SUSU_CHILDREN), value: None, }; -pub static WORD_SUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("bcribe"), - dictgen::InsensitiveStr::Ascii("btantial"), - dictgen::InsensitiveStr::Ascii("btantially"), - dictgen::InsensitiveStr::Ascii("btantive"), - dictgen::InsensitiveStr::Ascii("btrate"), - dictgen::InsensitiveStr::Ascii("cepitble"), - dictgen::InsensitiveStr::Ascii("ceptable"), - dictgen::InsensitiveStr::Ascii("ceptiable"), - dictgen::InsensitiveStr::Ascii("ceptibile"), - dictgen::InsensitiveStr::Ascii("cpetible"), - dictgen::InsensitiveStr::Ascii("ecptible"), - dictgen::InsensitiveStr::Ascii("eptable"), - dictgen::InsensitiveStr::Ascii("eptible"), - dictgen::InsensitiveStr::Ascii("ncreen"), - dictgen::InsensitiveStr::Ascii("pecions"), - dictgen::InsensitiveStr::Ascii("pecious"), - dictgen::InsensitiveStr::Ascii("peciously"), - dictgen::InsensitiveStr::Ascii("pectes"), - dictgen::InsensitiveStr::Ascii("pectible"), - dictgen::InsensitiveStr::Ascii("pencion"), - dictgen::InsensitiveStr::Ascii("pendeds"), - dictgen::InsensitiveStr::Ascii("pendes"), - dictgen::InsensitiveStr::Ascii("pened"), - dictgen::InsensitiveStr::Ascii("pensie"), - dictgen::InsensitiveStr::Ascii("penso"), - dictgen::InsensitiveStr::Ascii("pention"), - dictgen::InsensitiveStr::Ascii("picians"), - dictgen::InsensitiveStr::Ascii("piciois"), - dictgen::InsensitiveStr::Ascii("piciosly"), - dictgen::InsensitiveStr::Ascii("picioso"), - dictgen::InsensitiveStr::Ascii("picioulsy"), - dictgen::InsensitiveStr::Ascii("piciouly"), - dictgen::InsensitiveStr::Ascii("picioun"), - dictgen::InsensitiveStr::Ascii("piciouns"), - dictgen::InsensitiveStr::Ascii("picision"), - dictgen::InsensitiveStr::Ascii("picison"), - dictgen::InsensitiveStr::Ascii("picisons"), - dictgen::InsensitiveStr::Ascii("piciuos"), - dictgen::InsensitiveStr::Ascii("piciuosly"), - dictgen::InsensitiveStr::Ascii("picsion"), - dictgen::InsensitiveStr::Ascii("pisions"), - dictgen::InsensitiveStr::Ascii("pisious"), - dictgen::InsensitiveStr::Ascii("pisiously"), - dictgen::InsensitiveStr::Ascii("pitions"), - dictgen::InsensitiveStr::Ascii("tainabillity"), - dictgen::InsensitiveStr::Ascii("tainabiltiy"), - dictgen::InsensitiveStr::Ascii("tainabilty"), - dictgen::InsensitiveStr::Ascii("tainabily"), - dictgen::InsensitiveStr::Ascii("tainble"), - dictgen::InsensitiveStr::Ascii("tainible"), + dictgen::InsensitiveStr::Ascii("ainabillity"), + dictgen::InsensitiveStr::Ascii("ainabiltiy"), + dictgen::InsensitiveStr::Ascii("ainabilty"), + dictgen::InsensitiveStr::Ascii("ainabily"), + 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"], + &["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("inct")], + values: &[&["succinct"]], + range: 4..=4, +}; + +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: &[ - &["subscribe"], - &["substantial"], - &["substantially"], - &["substantive"], - &["substrate"], - &["susceptible"], - &["susceptible"], - &["susceptible"], - &["susceptible"], - &["susceptible"], - &["susceptible"], - &["susceptible"], - &["susceptible"], - &["sunscreen"], &["suspicions"], &["suspicious"], &["suspiciously"], &["suspects"], &["susceptible"], + &["suspend"], &["suspension"], &["suspense"], &["suspense"], &["suspend"], + &["suspended"], &["suspense"], &["suspension"], &["suspension"], &["suspicions"], &["suspicions"], - &["suspiciously"], - &["suspicions"], - &["suspiciously"], - &["suspiciously"], - &["suspicion"], - &["suspicion"], - &["suspicions"], - &["suspicions"], - &["suspicions"], - &["suspicions"], - &["suspiciously"], - &["suspicions"], - &["suspicions"], &["suspicious"], &["suspiciously"], &["suspicions"], - &["sustainability"], - &["sustainability"], - &["sustainability"], - &["sustainability"], - &["sustainable"], - &["sustainable"], + &["suspiciously"], + &["suspiciously"], + &["suspicion"], + &["suspicion"], + &["suspicions"], + &["suspicions"], + &["suspicions"], + &["suspicions"], + &["suspiciously"], + &["suspicious"], + &["suspiciously"], + &["suspicions"], + &["suspicion"], + &["suspicions"], + &["suspicious"], + &["suspiciously"], + &["suspicions"], + &["suspend"], ], - range: 5..=12, + 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("nctly"), + dictgen::InsensitiveStr::Ascii("nkt"), + ], + values: &[&["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("pect"), + dictgen::InsensitiveStr::Ascii("ptable"), + dictgen::InsensitiveStr::Ascii("ptible"), + ], + values: &[ + &["susceptible"], + &["suspect"], + &["susceptible"], + &["susceptible"], + ], + range: 4..=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("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: &[ + &["susceptible"], + &["susceptible"], + &["susceptible"], + &["susceptible"], + &["susceptible"], + &["subscribe"], + &["subscribed"], + &["subscribes"], + &["subscript"], + ], + range: 4..=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("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"], + &["subsystem"], + &["subsystems"], + &["subsystem"], + &["subsystems"], + &["substantial"], + &["substantially"], + &["substantive"], + &["substrate"], + ], + range: 5..=9, }; static WORD_SUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -9982,7 +19855,7 @@ static WORD_SUR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_SURF_NODE), - None, + Some(&WORD_SURG_NODE), None, None, None, @@ -10015,12 +19888,16 @@ pub static WORD_SURV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ices"), dictgen::InsensitiveStr::Ascii("iellance"), dictgen::InsensitiveStr::Ascii("ivabiity"), dictgen::InsensitiveStr::Ascii("ivabililty"), @@ -10043,12 +19920,16 @@ pub static WORD_SURV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["surveillance"], &["surveillance"], &["survivability"], + &["survey"], + &["surveys"], &["surveillance"], &["surveil"], &["surveillance"], &["surveillance"], &["surveyor"], &["survivability"], + &["service", "survive"], + &["services", "survives"], &["surveillance"], &["survivability"], &["survivability"], @@ -10066,7 +19947,7 @@ pub static WORD_SURV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["survivor"], &["survivor"], ], - range: 4..=10, + range: 2..=10, }; static WORD_SURR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10076,12 +19957,15 @@ static WORD_SURR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -10094,15 +19978,19 @@ pub static WORD_SURR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -10115,6 +20003,7 @@ pub static WORD_SURR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["surrounds"], &["surround"], &["surrounds"], + &["surrounded"], &["surrendering"], ], range: 3..=12, @@ -10130,9 +20019,16 @@ pub static WORD_SURP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -10143,9 +20039,16 @@ pub static WORD_SURP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["surpass"], &["supremacist"], &["supreme"], + &["surprise"], + &["surprises"], &["supplanted"], + &["support"], + &["supported"], &["suppress"], &["suppressed"], + &["suppresses"], + &["suppressing"], + &["surprisingly"], &["surprisingly"], &["surprise"], &["surprised"], @@ -10185,10 +20088,33 @@ static WORD_SURL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_SURL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[dictgen::InsensitiveStr::Ascii("ey")], - values: &[&["surly"]], + 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, @@ -10206,9 +20132,12 @@ static WORD_SURB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SURB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("uban")], - values: &[&["suburban"]], - range: 4..=4, + 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 { @@ -10262,6 +20191,10 @@ pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -10274,6 +20207,10 @@ pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["suspicions"], &["suspicious"], &["suspiciously"], + &["suspect"], + &["suspected"], + &["suspecting"], + &["suspects"], ], range: 3..=9, }; @@ -10291,15 +20228,27 @@ pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -10320,10 +20269,22 @@ pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["suppresses"], &["suppressing"], &["suppression"], + &["suppress"], + &["suppressed"], + &["suppresses"], + &["suppressible"], + &["suppressing"], + &["suppression"], + &["suppressions"], + &["suppressor"], + &["suppressors"], + &["suppression"], &["supremacist"], + &["spurious"], &["surprised"], &["surprise"], &["surprised"], + &["surprises"], &["surprising"], &["surprisingly"], &["surprise"], @@ -10332,54 +20293,229 @@ pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["surprisingly"], &["surprised"], ], - range: 3..=7, + range: 2..=7, }; static WORD_SUPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SUPP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SUPP_CHILDREN), value: None, }; -pub static WORD_SUPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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_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("erssor"), - dictgen::InsensitiveStr::Ascii("lament"), - dictgen::InsensitiveStr::Ascii("lamental"), - dictgen::InsensitiveStr::Ascii("lamented"), - dictgen::InsensitiveStr::Ascii("laments"), - dictgen::InsensitiveStr::Ascii("lemant"), - dictgen::InsensitiveStr::Ascii("lemetal"), - dictgen::InsensitiveStr::Ascii("lemets"), - dictgen::InsensitiveStr::Ascii("liementing"), - dictgen::InsensitiveStr::Ascii("limental"), - dictgen::InsensitiveStr::Ascii("oed"), - dictgen::InsensitiveStr::Ascii("orre"), - dictgen::InsensitiveStr::Ascii("ortare"), - dictgen::InsensitiveStr::Ascii("ortes"), - dictgen::InsensitiveStr::Ascii("orteur"), - dictgen::InsensitiveStr::Ascii("orteurs"), - dictgen::InsensitiveStr::Ascii("ortied"), - dictgen::InsensitiveStr::Ascii("ortors"), - dictgen::InsensitiveStr::Ascii("osdely"), - dictgen::InsensitiveStr::Ascii("osebly"), - dictgen::InsensitiveStr::Ascii("osedely"), - dictgen::InsensitiveStr::Ascii("osidely"), - dictgen::InsensitiveStr::Ascii("osidly"), - dictgen::InsensitiveStr::Ascii("osingly"), - dictgen::InsensitiveStr::Ascii("ost"), - dictgen::InsensitiveStr::Ascii("reses"), - dictgen::InsensitiveStr::Ascii("resion"), - dictgen::InsensitiveStr::Ascii("resions"), - dictgen::InsensitiveStr::Ascii("resors"), - dictgen::InsensitiveStr::Ascii("ressin"), - dictgen::InsensitiveStr::Ascii("ressio"), - dictgen::InsensitiveStr::Ascii("resson"), - dictgen::InsensitiveStr::Ascii("resssion"), - dictgen::InsensitiveStr::Ascii("resssor"), - dictgen::InsensitiveStr::Ascii("y"), + dictgen::InsensitiveStr::Ascii("es"), + 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"), ], values: &[ + &["suppress"], + &["suppress"], + &["suppression"], + &["suppression"], &["suppressor"], + &["suppression"], + &["suppressing"], + &["suppressor"], + &["suppression"], + &["suppression"], + &["suppressor"], + &["support"], + &["supported"], + &["supporter"], + &["supporters"], + &["supporting"], + &["supports"], + &["support"], + &["supported"], + ], + 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("ort"), + dictgen::InsensitiveStr::Ascii("orted"), + dictgen::InsensitiveStr::Ascii("orting"), + dictgen::InsensitiveStr::Ascii("orts"), + ], + values: &[ + &["supplied"], + &["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("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("rtted"), + dictgen::InsensitiveStr::Ascii("sdely"), + 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("ted"), + ], + values: &[ + &["supposed"], + &["support"], + &["support"], + &["supports"], + &["suppose"], + &["support"], + &["supported"], + &["support"], + &["supported"], + &["suppression"], + &["supporters"], + &["supporters"], + &["supported"], + &["supported", "supporter"], + &["supports"], + &["supporter", "supported"], + &["supporter"], + &["supporters"], + &["supported"], + &["supporting"], + &["supporters"], + &["supported"], + &["supposedly"], + &["supposedly"], + &["supposed"], + &["supposedly"], + &["supposed"], + &["supposedly"], + &["supposedly"], + &["supposedly"], + &["supposedly"], + &["supposed"], + &["supports"], + &["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"), + ], + values: &[ &["supplement"], &["supplemental"], &["supplemented"], @@ -10387,35 +20523,38 @@ pub static WORD_SUPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["supplemental"], &["supplemental"], &["supplements"], + &["supplied"], &["supplementing"], + &["supplement"], &["supplemental"], - &["supposed"], - &["supporters"], - &["supporters"], - &["supports"], - &["supporter"], - &["supporters"], - &["supported"], - &["supporters"], - &["supposedly"], - &["supposedly"], - &["supposedly"], - &["supposedly"], - &["supposedly"], - &["supposedly"], - &["supports"], - &["suppress"], - &["suppression"], - &["suppression"], - &["suppressor"], - &["suppression"], - &["suppressor"], - &["suppression"], - &["suppression"], - &["suppressor"], - &["supply"], ], - range: 1..=10, + 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 { @@ -10426,19 +20565,29 @@ static WORD_SUPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_SUPO_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"), + dictgen::InsensitiveStr::Ascii("rtted"), dictgen::InsensitiveStr::Ascii("se"), 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"], + &["supported"], &["suppose"], &["supposed"], &["supposedly"], &["supposes"], &["supposing"], + &["suppose"], ], range: 2..=5, }; @@ -10450,11 +20599,28 @@ static WORD_SUPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["supplemented"], &["supplemental"]], - range: 7..=8, + values: &[ + &["supplant"], + &["supplanted"], + &["supplanting"], + &["supplants"], + &["supplementary"], + &["supplied"], + &["supplemented"], + &["supplemental"], + &["supplies"], + ], + range: 3..=8, }; static WORD_SUPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10486,10 +20652,10 @@ static WORD_SUPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_SUPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ None, + Some(&WORD_SUPEB_NODE), None, None, - None, - None, + Some(&WORD_SUPEE_NODE), None, None, None, @@ -10593,6 +20759,10 @@ static WORD_SUPERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("eedd"), + dictgen::InsensitiveStr::Ascii("eede"), + dictgen::InsensitiveStr::Ascii("eeded"), dictgen::InsensitiveStr::Ascii("ition"), dictgen::InsensitiveStr::Ascii("ticion"), dictgen::InsensitiveStr::Ascii("ticious"), @@ -10606,6 +20776,10 @@ pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("tituous"), ], values: &[ + &["superseded"], + &["superseded"], + &["supersede"], + &["superseded"], &["supervision"], &["superstition"], &["superstitious"], @@ -10618,7 +20792,7 @@ pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["superstitious"], &["superstitious"], ], - range: 5..=7, + range: 2..=7, }; static WORD_SUPERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10641,9 +20815,12 @@ static WORD_SUPERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_SUPERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("uman")], - values: &[&["superhuman"]], - range: 4..=4, + 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 { @@ -10765,6 +20942,10 @@ pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -10775,8 +20956,12 @@ pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["superfluous"], &["superfluous"], &["superfluous"], + &["superfluous"], + &["superfluous"], + &["superfluous"], + &["superfluous"], ], - range: 3..=5, + range: 3..=6, }; static WORD_SUPERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10785,9 +20970,47 @@ static WORD_SUPERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_SUPERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("eeded")], - values: &[&["superseded"]], - range: 5..=5, + 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"), + ], + values: &[ + &["supercalifragilisticexpialidocious"], + &["supersede"], + &["superseded"], + &["supersedes"], + &["superseding"], + &["supersede"], + &["superseded"], + ], + range: 3..=28, +}; + +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 { @@ -10823,6 +21046,7 @@ pub static WORD_SUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ifre"), dictgen::InsensitiveStr::Ascii("screeen"), dictgen::InsensitiveStr::Ascii("scren"), + dictgen::InsensitiveStr::Ascii("task"), ], values: &[ &["subconscious"], @@ -10840,6 +21064,7 @@ pub static WORD_SUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sunfire"], &["sunscreen"], &["sunscreen"], + &["subtask"], ], range: 4..=11, }; @@ -10851,42 +21076,91 @@ static WORD_SUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("amry"), 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("bitted"), dictgen::InsensitiveStr::Ascii("bitting"), + 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("murized"), + dictgen::InsensitiveStr::Ascii("odules"), ], values: &[ + &["summary"], &["summary"], &["submarine"], &["submarines"], &["submerged"], &["submissions"], &["submissive"], + &["submitted"], &["submitting"], + &["summary"], &["summoner"], &["summoners"], + &["summarised"], &["summarized"], + &["somersault"], + &["summaries"], + &["summarisation"], + &["summarised"], + &["summarization"], + &["summarized"], + &["summary"], &["summoners"], &["summoners"], &["summoner"], &["summoner"], &["summarized"], &["summarized"], + &["submodules"], ], - range: 3..=8, + 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 { @@ -10896,6 +21170,10 @@ static WORD_SUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("geste"), dictgen::InsensitiveStr::Ascii("gestes"), @@ -10904,8 +21182,32 @@ pub static WORD_SUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("gestief"), dictgen::InsensitiveStr::Ascii("gestieve"), 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"], &["suggestive"], &["suggests"], @@ -10914,8 +21216,28 @@ pub static WORD_SUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["suggestive"], &["suggestive"], &["suggests"], + &["suggested"], + &["suggested"], + &["suggestion"], + &["suggestions"], + &["suggest"], + &["suggested"], + &["suggest", "suggests"], + &["suggested"], + &["suggesting"], + &["suggestion"], + &["suggest"], + &["suggested"], + &["suggesting"], + &["suggestion"], + &["suggestions"], + &["suggest"], + &["suggested"], + &["suggesting"], + &["suggestion"], + &["suggestions"], ], - range: 5..=8, + range: 3..=9, }; static WORD_SUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10925,28 +21247,74 @@ static WORD_SUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ferage"), dictgen::InsensitiveStr::Ascii("ferd"), dictgen::InsensitiveStr::Ascii("ferered"), dictgen::InsensitiveStr::Ascii("ferred"), dictgen::InsensitiveStr::Ascii("ferring"), + dictgen::InsensitiveStr::Ascii("ficate"), + dictgen::InsensitiveStr::Ascii("ficated"), + dictgen::InsensitiveStr::Ascii("ficates"), + dictgen::InsensitiveStr::Ascii("ficating"), + dictgen::InsensitiveStr::Ascii("fication"), dictgen::InsensitiveStr::Ascii("ficent"), dictgen::InsensitiveStr::Ascii("ficently"), dictgen::InsensitiveStr::Ascii("ficiant"), dictgen::InsensitiveStr::Ascii("ficit"), + 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"], &["suffrage"], &["suffered"], &["suffered"], &["suffered"], &["suffering"], + &["suffocate"], + &["suffocated"], + &["suffocates"], + &["suffocating"], + &["suffocation"], &["sufficient"], &["sufficiently"], &["sufficient"], &["sufficient"], + &["sophisticated"], + &["suffocate"], + &["suffocated"], + &["suffocates"], + &["suffocating"], + &["suffocation"], + &["sufficient"], + &["sufficient"], + &["sufficiently"], + &["suffocate"], + &["suffocated"], + &["suffocates"], + &["suffocating"], + &["suffocation"], ], - range: 4..=8, + range: 3..=10, }; static WORD_SUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10955,9 +21323,12 @@ static WORD_SUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("full")], - values: &[&["usefull"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ful"), + dictgen::InsensitiveStr::Ascii("full"), + ], + values: &[&["useful"], &["usefull"]], + range: 3..=4, }; static WORD_SUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -10969,110 +21340,152 @@ pub static WORD_SUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("deny"), dictgen::InsensitiveStr::Ascii("dnely"), + dictgen::InsensitiveStr::Ascii("ent"), + dictgen::InsensitiveStr::Ascii("ents"), + dictgen::InsensitiveStr::Ascii("mobule"), + dictgen::InsensitiveStr::Ascii("mobules"), dictgen::InsensitiveStr::Ascii("nerland"), ], - values: &[&["suddenly"], &["suddenly"], &["sunderland"]], - range: 4..=7, + values: &[ + &["suddenly"], + &["suddenly"], + &["student"], + &["students"], + &["submodule"], + &["submodules"], + &["sunderland"], + ], + range: 3..=7, }; static WORD_SUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SUC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SUC_CHILDREN), value: None, }; -pub static WORD_SUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("cceeded"), - dictgen::InsensitiveStr::Ascii("ccesses"), - dictgen::InsensitiveStr::Ascii("cedded"), - dictgen::InsensitiveStr::Ascii("cede"), - dictgen::InsensitiveStr::Ascii("ceded"), - dictgen::InsensitiveStr::Ascii("cedes"), - dictgen::InsensitiveStr::Ascii("ceds"), - dictgen::InsensitiveStr::Ascii("ceedes"), - dictgen::InsensitiveStr::Ascii("ceeed"), - dictgen::InsensitiveStr::Ascii("cees"), - dictgen::InsensitiveStr::Ascii("cesd"), - dictgen::InsensitiveStr::Ascii("cesed"), - dictgen::InsensitiveStr::Ascii("cesful"), - dictgen::InsensitiveStr::Ascii("cesfully"), - dictgen::InsensitiveStr::Ascii("cesfuly"), - dictgen::InsensitiveStr::Ascii("cesion"), - dictgen::InsensitiveStr::Ascii("cesions"), - dictgen::InsensitiveStr::Ascii("cesive"), - dictgen::InsensitiveStr::Ascii("cesseurs"), - dictgen::InsensitiveStr::Ascii("cessfull"), - dictgen::InsensitiveStr::Ascii("cessfullly"), - dictgen::InsensitiveStr::Ascii("cessfuly"), - dictgen::InsensitiveStr::Ascii("cessing"), - dictgen::InsensitiveStr::Ascii("cessivo"), - dictgen::InsensitiveStr::Ascii("cesss"), - dictgen::InsensitiveStr::Ascii("cesssion"), - dictgen::InsensitiveStr::Ascii("cessully"), - dictgen::InsensitiveStr::Ascii("csesfull"), - dictgen::InsensitiveStr::Ascii("csess"), - dictgen::InsensitiveStr::Ascii("csessfull"), - dictgen::InsensitiveStr::Ascii("eed"), - dictgen::InsensitiveStr::Ascii("eeded"), - dictgen::InsensitiveStr::Ascii("eeding"), - dictgen::InsensitiveStr::Ascii("eeds"), - dictgen::InsensitiveStr::Ascii("esful"), - dictgen::InsensitiveStr::Ascii("esfully"), - dictgen::InsensitiveStr::Ascii("esfuly"), - dictgen::InsensitiveStr::Ascii("esion"), - dictgen::InsensitiveStr::Ascii("ess"), - dictgen::InsensitiveStr::Ascii("esses"), - dictgen::InsensitiveStr::Ascii("essful"), - dictgen::InsensitiveStr::Ascii("essfull"), - dictgen::InsensitiveStr::Ascii("essfully"), - dictgen::InsensitiveStr::Ascii("essfuly"), - dictgen::InsensitiveStr::Ascii("ession"), - dictgen::InsensitiveStr::Ascii("essive"), - dictgen::InsensitiveStr::Ascii("essor"), - dictgen::InsensitiveStr::Ascii("essot"), - dictgen::InsensitiveStr::Ascii("ide"), - dictgen::InsensitiveStr::Ascii("idial"), - dictgen::InsensitiveStr::Ascii("septible"), + dictgen::InsensitiveStr::Ascii("ede"), + dictgen::InsensitiveStr::Ascii("eptible"), + ], + values: &[&["succeed"], &["susceptible"]], + 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("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: &[ - &["succeeded"], - &["successes"], - &["succeeded"], - &["succeed"], - &["succeeded"], - &["succeeds"], - &["succeeds"], - &["succeeds"], - &["succeed"], - &["succeeds"], - &["succeeds"], - &["succeeds"], - &["successful"], - &["successfully"], - &["successfully"], - &["succession"], - &["succession"], - &["successive"], - &["successes"], - &["successful"], - &["successfully"], - &["successfully"], - &["succession"], - &["succession"], - &["successes"], - &["succession"], - &["successfully"], - &["successfully"], - &["success"], - &["successful"], &["succeed"], &["succeeded"], &["succeeding"], &["succeeds"], - &["successful"], - &["successfully"], - &["successfully"], - &["succession"], &["success"], &["successes"], &["successful"], @@ -11081,13 +21494,169 @@ pub static WORD_SUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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"], - &["suicide"], - &["suicidal"], - &["susceptible"], + &["success"], + &["successes"], + &["successful"], + &["successful"], + &["successfully"], + &["successfully"], + &["successful"], + &["successfully"], + &["successfully"], ], - range: 3..=10, + range: 1..=8, +}; + +static WORD_SUCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SUCC_CHILDREN), + value: None, +}; + +pub static WORD_SUCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("ceeded"), + dictgen::InsensitiveStr::Ascii("cess"), + dictgen::InsensitiveStr::Ascii("cesses"), + dictgen::InsensitiveStr::Ascii("cessful"), + dictgen::InsensitiveStr::Ascii("cessfully"), + dictgen::InsensitiveStr::Ascii("cessor"), + dictgen::InsensitiveStr::Ascii("cessors"), + dictgen::InsensitiveStr::Ascii("cessul"), + dictgen::InsensitiveStr::Ascii("cessully"), + dictgen::InsensitiveStr::Ascii("ecful"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("edd"), + dictgen::InsensitiveStr::Ascii("edded"), + dictgen::InsensitiveStr::Ascii("edding"), + dictgen::InsensitiveStr::Ascii("edds"), + dictgen::InsensitiveStr::Ascii("ede"), + dictgen::InsensitiveStr::Ascii("eded"), + dictgen::InsensitiveStr::Ascii("edes"), + dictgen::InsensitiveStr::Ascii("edfully"), + dictgen::InsensitiveStr::Ascii("eding"), + dictgen::InsensitiveStr::Ascii("eds"), + dictgen::InsensitiveStr::Ascii("eedes"), + dictgen::InsensitiveStr::Ascii("eeed"), + dictgen::InsensitiveStr::Ascii("ees"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("esd"), + dictgen::InsensitiveStr::Ascii("esed"), + dictgen::InsensitiveStr::Ascii("esful"), + dictgen::InsensitiveStr::Ascii("esfull"), + dictgen::InsensitiveStr::Ascii("esfully"), + dictgen::InsensitiveStr::Ascii("esfuly"), + dictgen::InsensitiveStr::Ascii("esion"), + dictgen::InsensitiveStr::Ascii("esions"), + dictgen::InsensitiveStr::Ascii("esive"), + dictgen::InsensitiveStr::Ascii("esor"), + dictgen::InsensitiveStr::Ascii("esors"), + dictgen::InsensitiveStr::Ascii("essed"), + dictgen::InsensitiveStr::Ascii("esseurs"), + dictgen::InsensitiveStr::Ascii("essfule"), + dictgen::InsensitiveStr::Ascii("essfull"), + dictgen::InsensitiveStr::Ascii("essfullies"), + dictgen::InsensitiveStr::Ascii("essfullly"), + dictgen::InsensitiveStr::Ascii("essfulln"), + dictgen::InsensitiveStr::Ascii("essfullness"), + dictgen::InsensitiveStr::Ascii("essfullt"), + dictgen::InsensitiveStr::Ascii("essfuly"), + dictgen::InsensitiveStr::Ascii("essing"), + dictgen::InsensitiveStr::Ascii("essivo"), + dictgen::InsensitiveStr::Ascii("esss"), + dictgen::InsensitiveStr::Ascii("esssfully"), + dictgen::InsensitiveStr::Ascii("esssion"), + dictgen::InsensitiveStr::Ascii("essul"), + dictgen::InsensitiveStr::Ascii("essully"), + dictgen::InsensitiveStr::Ascii("int"), + dictgen::InsensitiveStr::Ascii("seeded"), + dictgen::InsensitiveStr::Ascii("sesfull"), + dictgen::InsensitiveStr::Ascii("sess"), + dictgen::InsensitiveStr::Ascii("sessfull"), + dictgen::InsensitiveStr::Ascii("sessive"), + ], + values: &[ + &["succeeded"], + &["success"], + &["successes"], + &["successful"], + &["successfully"], + &["successor"], + &["successors"], + &["successful"], + &["successfully"], + &["successful"], + &["succeed"], + &["succeed"], + &["succeeded"], + &["succeeding"], + &["succeeds"], + &["succeed"], + &["succeeded"], + &["succeeds"], + &["successfully"], + &["succeeding"], + &["succeeds"], + &["succeeds"], + &["succeed", "succeeded"], + &["succeeds", "success"], + &["success"], + &["succeeds"], + &["succeeds"], + &["successful"], + &["successful"], + &["successfully"], + &["successfully"], + &["succession"], + &["succession"], + &["successive"], + &["successor"], + &["successors"], + &["succeeded", "success", "successful"], + &["successes"], + &["successful"], + &["successful"], + &["successfully"], + &["successfully"], + &["successful"], + &["successfulness"], + &["successfully"], + &["successfully"], + &["succession", "successive"], + &["succession"], + &["successes", "success"], + &["successfully"], + &["succession"], + &["successful"], + &["successfully"], + &["succinct"], + &["succeeded"], + &["successfully"], + &["success"], + &["successful"], + &["successive"], + ], + range: 2..=11, }; static WORD_SUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11099,9 +21668,9 @@ static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_SUBA_NODE), None, Some(&WORD_SUBC_NODE), - None, + Some(&WORD_SUBD_NODE), Some(&WORD_SUBE_NODE), - None, + Some(&WORD_SUBF_NODE), None, None, Some(&WORD_SUBI_NODE), @@ -11109,10 +21678,10 @@ static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_SUBL_NODE), Some(&WORD_SUBM_NODE), - None, - None, + Some(&WORD_SUBN_NODE), + Some(&WORD_SUBO_NODE), Some(&WORD_SUBP_NODE), - None, + Some(&WORD_SUBQ_NODE), Some(&WORD_SUBR_NODE), Some(&WORD_SUBS_NODE), Some(&WORD_SUBT_NODE), @@ -11120,10 +21689,24 @@ static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, 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, @@ -11142,7 +21725,10 @@ static WORD_SUBT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("abels"), dictgen::InsensitiveStr::Ascii("ances"), + dictgen::InsensitiveStr::Ascii("arger"), + dictgen::InsensitiveStr::Ascii("argers"), dictgen::InsensitiveStr::Ascii("elty"), dictgen::InsensitiveStr::Ascii("erranian"), dictgen::InsensitiveStr::Ascii("etly"), @@ -11153,12 +21739,26 @@ pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ring"), + dictgen::InsensitiveStr::Ascii("rings"), + dictgen::InsensitiveStr::Ascii("situtable"), + dictgen::InsensitiveStr::Ascii("situtatble"), ], values: &[ + &["subtables"], &["substances"], + &["subtarget"], + &["subtargets"], &["subtlety"], &["subterranean"], &["subtlety"], @@ -11169,11 +21769,22 @@ pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["subtitles"], &["subtitles"], &["subtitle"], + &["substitute"], + &["substituted"], + &["substitutes"], + &["substituting"], + &["substitution"], + &["substitutions"], &["subtlety"], &["subtlety"], &["subtitles"], + &["subterfuge"], + &["substring"], + &["substrings"], + &["substitutable"], + &["substitutable"], ], - range: 3..=8, + range: 3..=10, }; static WORD_SUBS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11189,7 +21800,7 @@ static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_SUBSE_NODE), None, None, - None, + Some(&WORD_SUBSH_NODE), Some(&WORD_SUBSI_NODE), None, None, @@ -11206,10 +21817,39 @@ static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, 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, @@ -11222,71 +21862,212 @@ pub static WORD_SUBSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_SUBST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SUBST_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SUBST_CHILDREN), value: None, }; -pub static WORD_SUBST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ace"), - dictgen::InsensitiveStr::Ascii("ancial"), - dictgen::InsensitiveStr::Ascii("ancially"), - dictgen::InsensitiveStr::Ascii("anial"), - dictgen::InsensitiveStr::Ascii("anitally"), - dictgen::InsensitiveStr::Ascii("ans"), - dictgen::InsensitiveStr::Ascii("anse"), - dictgen::InsensitiveStr::Ascii("ansen"), - dictgen::InsensitiveStr::Ascii("anser"), - dictgen::InsensitiveStr::Ascii("anses"), - dictgen::InsensitiveStr::Ascii("ansial"), - dictgen::InsensitiveStr::Ascii("ansially"), - dictgen::InsensitiveStr::Ascii("ansive"), - dictgen::InsensitiveStr::Ascii("anta"), - dictgen::InsensitiveStr::Ascii("ante"), - dictgen::InsensitiveStr::Ascii("antiable"), - dictgen::InsensitiveStr::Ascii("antialy"), - dictgen::InsensitiveStr::Ascii("antie"), - dictgen::InsensitiveStr::Ascii("antied"), - dictgen::InsensitiveStr::Ascii("anties"), - dictgen::InsensitiveStr::Ascii("antitve"), - dictgen::InsensitiveStr::Ascii("antually"), - dictgen::InsensitiveStr::Ascii("arte"), - dictgen::InsensitiveStr::Ascii("atial"), - dictgen::InsensitiveStr::Ascii("ences"), - dictgen::InsensitiveStr::Ascii("ential"), - dictgen::InsensitiveStr::Ascii("ite"), - dictgen::InsensitiveStr::Ascii("itite"), - dictgen::InsensitiveStr::Ascii("itition"), - dictgen::InsensitiveStr::Ascii("itiute"), - dictgen::InsensitiveStr::Ascii("ittue"), - dictgen::InsensitiveStr::Ascii("itude"), - dictgen::InsensitiveStr::Ascii("ituded"), - dictgen::InsensitiveStr::Ascii("itudes"), - dictgen::InsensitiveStr::Ascii("itue"), - dictgen::InsensitiveStr::Ascii("itued"), - dictgen::InsensitiveStr::Ascii("ituer"), - dictgen::InsensitiveStr::Ascii("itues"), - dictgen::InsensitiveStr::Ascii("ituion"), - dictgen::InsensitiveStr::Ascii("iture"), - dictgen::InsensitiveStr::Ascii("itures"), - dictgen::InsensitiveStr::Ascii("itutents"), - dictgen::InsensitiveStr::Ascii("ituters"), - dictgen::InsensitiveStr::Ascii("itutie"), - dictgen::InsensitiveStr::Ascii("itutivo"), - dictgen::InsensitiveStr::Ascii("ituto"), - dictgen::InsensitiveStr::Ascii("itutos"), - dictgen::InsensitiveStr::Ascii("ituts"), - dictgen::InsensitiveStr::Ascii("itutue"), - dictgen::InsensitiveStr::Ascii("itutues"), - dictgen::InsensitiveStr::Ascii("ract"), - dictgen::InsensitiveStr::Ascii("racted"), - dictgen::InsensitiveStr::Ascii("racting"), - dictgen::InsensitiveStr::Ascii("raction"), - dictgen::InsensitiveStr::Ascii("racts"), - dictgen::InsensitiveStr::Ascii("utite"), + 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("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("tuters"), + dictgen::InsensitiveStr::Ascii("tutie"), + 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"), + ], + values: &[ + &["substitute"], + &["substitution"], + &["substitutions"], + &["substitute"], + &["substitution"], + &["substitutions"], + &["substitute"], + &["substitutes"], + &["substitution"], + &["substitutions"], + &["substitute"], + &["substituted"], + &["substitutes"], + &["substituting"], + &["substitute"], + &["substitute", "substituted"], + &["substitute"], + &["substitutes"], + &["substituting"], + &["substitution"], + &["substitutions"], + &["substitute"], + &["substitutes"], + &["substitutes"], + &["substitutes"], + &["substitutes"], + &["substitution"], + &["substitution"], + &["substitutes"], + &["substitutes"], + &["substitutes"], + &["substitutes"], + &["substitution"], + ], + 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"), + ], + values: &[&["substances"], &["substantial"]], + range: 4..=5, +}; + +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("ntually"), + dictgen::InsensitiveStr::Ascii("rte"), + dictgen::InsensitiveStr::Ascii("tial"), ], values: &[ &["substance"], + &["subtract"], + &["substantially"], &["substantial"], &["substantially"], &["substantial"], @@ -11310,40 +22091,8 @@ pub static WORD_SUBST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["substantially"], &["substrate"], &["substantial"], - &["substances"], - &["substantial"], - &["substitute"], - &["substitute"], - &["substitution"], - &["substitute"], - &["substitutes"], - &["substitute"], - &["substituted"], - &["substitutes"], - &["substitute"], - &["substitute"], - &["substitute"], - &["substitutes"], - &["substitution"], - &["substitute"], - &["substitutes"], - &["substitutes"], - &["substitutes"], - &["substitutes"], - &["substitution"], - &["substitution"], - &["substitutes"], - &["substitutes"], - &["substitutes"], - &["substitutes"], - &["subtract"], - &["subtracted"], - &["subtracting"], - &["subtraction"], - &["subtracts"], - &["substitutes"], ], - range: 3..=8, + range: 2..=8, }; static WORD_SUBSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11357,6 +22106,7 @@ pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("cibed"), dictgen::InsensitiveStr::Ascii("cibers"), dictgen::InsensitiveStr::Ascii("ciption"), + dictgen::InsensitiveStr::Ascii("iber"), dictgen::InsensitiveStr::Ascii("icption"), ], values: &[ @@ -11364,6 +22114,7 @@ pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["subscribed"], &["subscribers"], &["subscriptions"], + &["subscriber"], &["subscriptions"], ], range: 4..=7, @@ -11403,6 +22154,22 @@ pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("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"), @@ -11421,11 +22188,41 @@ pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["subsequent"], &["subsequently"], &["substitutes"], + &["substituent"], + &["substituents"], + &["substitutable"], + &["substitutable"], + &["substitute"], + &["substituted"], + &["substitutes"], + &["substituting"], + &["substitution"], + &["substituent"], + &["substituents"], + &["substitute"], + &["substituted"], + &["substitutes"], + &["substituting"], + &["substitution"], &["subsidize"], &["subsidized"], &["subsidizing"], ], - range: 3..=7, + 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 { @@ -11435,12 +22232,32 @@ static WORD_SUBSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), ], - values: &[&["subsidized"], &["subsequent"], &["subsequently"]], - range: 5..=6, + values: &[ + &["subsection"], + &["subsequent"], + &["subsidized"], + &["subsequence"], + &["subsequent"], + &["subsequent"], + &["subsequently"], + &["subsequent"], + &["subsequence"], + &["subsequent"], + &["subsequently"], + ], + range: 4..=6, }; static WORD_SUBSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11450,11 +22267,20 @@ static WORD_SUBSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -11474,15 +22300,30 @@ pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), ], values: &[ + &["susceptible"], &["subscribe"], &["subscribed"], + &["subscriber"], &["subscribers"], + &["subscribe"], + &["subscribed"], + &["subscribers", "subscriber"], &["subscribers"], + &["subscribes"], + &["subscribing"], + &["subscript"], + &["subscriptions", "subscription"], &["subscriptions"], &["subconscious"], &["subconsciously"], @@ -11502,6 +22343,12 @@ pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["subscriptions"], &["subscription"], &["subscriptions"], + &["subscriptions", "subscription"], + &["subscriptions"], + &["subscription"], + &["subscriptions"], + &["subscript"], + &["subscription"], &["subscriptions"], &["subscriptions"], &["subscribed"], @@ -11528,12 +22375,39 @@ static WORD_SUBR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("outie"), + dictgen::InsensitiveStr::Ascii("outies"), dictgen::InsensitiveStr::Ascii("uban"), ], - values: &[&["subreddits"], &["subreddits"], &["suburban"]], - range: 4..=8, + values: &[ + &["subtract"], + &["subtracted"], + &["subtraction"], + &["subreddits"], + &["subreddits"], + &["subtree"], + &["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 { @@ -11542,11 +22416,144 @@ static WORD_SUBP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SUBP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ecies")], - values: &[&["subspecies"]], + 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("utine"), + ], + values: &[&["subobjects"], &["subroutine"]], range: 5..=5, }; +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, @@ -11561,11 +22568,19 @@ pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ergerd"), dictgen::InsensitiveStr::Ascii("ergered"), dictgen::InsensitiveStr::Ascii("erines"), + dictgen::InsensitiveStr::Ascii("ision"), 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("ition"), + dictgen::InsensitiveStr::Ascii("itions"), dictgen::InsensitiveStr::Ascii("ittion"), + dictgen::InsensitiveStr::Ascii("ittted"), + dictgen::InsensitiveStr::Ascii("oule"), + dictgen::InsensitiveStr::Ascii("ti"), ], values: &[ &["submachine"], @@ -11575,13 +22590,21 @@ pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["submerged"], &["submerged"], &["submarines"], + &["submission"], &["submissions"], &["submissions"], &["submissive"], + &["submission"], + &["submissions"], + &["submitted"], + &["submission"], &["submissions"], &["submitting"], + &["submitted"], + &["submodule"], + &["submit"], ], - range: 4..=7, + range: 2..=7, }; static WORD_SUBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11590,9 +22613,25 @@ static WORD_SUBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SUBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tety")], - values: &[&["subtlety"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ass"), + dictgen::InsensitiveStr::Ascii("asse"), + dictgen::InsensitiveStr::Ascii("asses"), + dictgen::InsensitiveStr::Ascii("casses"), + dictgen::InsensitiveStr::Ascii("cuase"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("tety"), + ], + values: &[ + &["subclass"], + &["subclasse"], + &["subclasses"], + &["subclasses"], + &["subclause"], + &["subtle"], + &["subtlety"], + ], + range: 1..=6, }; static WORD_SUBJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11602,6 +22641,7 @@ static WORD_SUBJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -11612,9 +22652,11 @@ pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -11625,9 +22667,10 @@ pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["subjectively"], &["subjective"], &["subjects"], + &["subject"], &["subjugation"], ], - range: 3..=9, + range: 2..=9, }; static WORD_SUBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11637,14 +22680,35 @@ static WORD_SUBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["subsidized"], &["subsidizing"], &["subsidy"]], + values: &[ + &["subdirectory"], + &["subsidized"], + &["subsidizing"], + &["subsidy"], + ], range: 3..=7, }; +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("roms"), + ], + values: &[&["subfolder"], &["subfolders"], &["subforms"]], + range: 4..=6, +}; + static WORD_SUBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_SUBE_CHILDREN), value: None, @@ -11652,11 +22716,69 @@ static WORD_SUBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["subsequent"], &["subsequently"]], - range: 6..=8, + 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("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"], + &["subdirectory"], + &["subdivision"], + &["subdivisioned"], + &["subdomain"], + &["subdomains"], + ], + range: 5..=10, }; static WORD_SUBC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11668,6 +22790,10 @@ pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -11678,6 +22804,10 @@ pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("sription"), dictgen::InsensitiveStr::Ascii("ulter"), dictgen::InsensitiveStr::Ascii("ultuur"), @@ -11685,6 +22815,10 @@ pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["subcategories"], &["subcategory"], + &["subcircuit"], + &["subcommand"], + &["subcommand"], + &["subconscious"], &["subconscious"], &["subconsciously"], &["subconsciously"], @@ -11695,11 +22829,15 @@ pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["subconsciously"], &["subconsciously"], &["subconscious"], + &["subscribe"], + &["subscribed"], + &["subscribes"], + &["subscribing"], &["subscriptions"], &["subculture"], &["subculture"], ], - range: 5..=10, + range: 4..=10, }; static WORD_SUBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11738,8 +22876,8 @@ static WORD_ST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_STA_NODE), None, - None, - None, + Some(&WORD_STC_NODE), + Some(&WORD_STD_NODE), Some(&WORD_STE_NODE), None, None, @@ -11749,12 +22887,12 @@ static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_STL_NODE), None, - None, + Some(&WORD_STN_NODE), Some(&WORD_STO_NODE), Some(&WORD_STP_NODE), None, Some(&WORD_STR_NODE), - None, + Some(&WORD_STS_NODE), Some(&WORD_STT_NODE), Some(&WORD_STU_NODE), None, @@ -11771,12 +22909,20 @@ static WORD_STY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_STY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("he"), + dictgen::InsensitiveStr::Ascii("ilistic"), dictgen::InsensitiveStr::Ascii("lisch"), dictgen::InsensitiveStr::Ascii("rofaom"), dictgen::InsensitiveStr::Ascii("rofom"), ], - values: &[&["stylish"], &["styrofoam"], &["styrofoam"]], - range: 5..=6, + values: &[ + &["style"], + &["stylistic"], + &["stylish"], + &["styrofoam"], + &["styrofoam"], + ], + range: 2..=7, }; static WORD_STU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11786,19 +22932,33 @@ static WORD_STU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -11814,22 +22974,42 @@ pub static WORD_STU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["study", "studio"], &["studying"], &["studios"], - &["struggling"], + &["studies", "studios"], + &["studio"], &["studios"], + &["struggling"], + &["studio"], + &["studios"], + &["still"], &["stupider"], &["stumbled"], + &["stomach"], &["tsunami"], &["stupidly"], &["stupider"], @@ -11845,9 +23025,15 @@ pub static WORD_STU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["struggled"], &["struggles"], &["struggling"], + &["structure"], + &["structured"], + &["structures"], + &["structure"], + &["shutdown"], &["stuttering"], + &["status"], ], - range: 3..=8, + range: 2..=8, }; static WORD_STT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11856,9 +23042,32 @@ static WORD_STT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_STT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("utering")], - values: &[&["stuttering"]], - range: 7..=7, + keys: &[ + dictgen::InsensitiveStr::Ascii("eting"), + dictgen::InsensitiveStr::Ascii("etings"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ings"), + dictgen::InsensitiveStr::Ascii("utering"), + ], + values: &[ + &["setting"], + &["settings"], + &["string", "setting", "sitting"], + &["strings", "settings", "sittings"], + &["stuttering"], + ], + range: 3..=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("tr")], + values: &[&["strstr"]], + range: 2..=2, }; static WORD_STR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11869,7 +23078,7 @@ static WORD_STR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_STR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_STRA_NODE), None, - None, + Some(&WORD_STRC_NODE), None, Some(&WORD_STRE_NODE), None, @@ -11924,40 +23133,88 @@ static WORD_STRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_STRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("c"), + 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("ctire"), + dictgen::InsensitiveStr::Ascii("ctre"), + dictgen::InsensitiveStr::Ascii("ctred"), + dictgen::InsensitiveStr::Ascii("ctres"), dictgen::InsensitiveStr::Ascii("ctrual"), 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("cure"), 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("ttural"), + dictgen::InsensitiveStr::Ascii("tture"), + dictgen::InsensitiveStr::Ascii("ture"), ], values: &[ + &["struct"], + &["structure"], &["structured"], - &["structural"], - &["structural"], - &["structural"], &["structures"], + &["structured"], + &["structure"], + &["structure"], + &["structured"], &["structures"], + &["structure"], + &["structure"], + &["structured"], + &["structures"], + &["structural"], &["structural"], &["structure"], &["structured"], &["structures"], + &["structure"], + &["structural"], + &["structures"], + &["structures"], + &["structure"], + &["structural"], + &["structure"], + &["structured"], + &["structures"], + &["structure"], + &["struggle"], &["struggled"], + &["struggled"], + &["struggling"], &["struggles"], &["struggles"], &["struggling"], &["struggling"], + &["structural"], + &["structure"], + &["structure"], ], - range: 5..=7, + range: 1..=7, }; static WORD_STRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -11967,19 +23224,39 @@ static WORD_STRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("re"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("res"), + dictgen::InsensitiveStr::Ascii("ring"), + dictgen::InsensitiveStr::Ascii("tage"), dictgen::InsensitiveStr::Ascii("y"), dictgen::InsensitiveStr::Ascii("yline"), dictgen::InsensitiveStr::Ascii("ylines"), dictgen::InsensitiveStr::Ascii("ytelling"), ], values: &[ + &["storage"], + &["store"], + &["storing"], &["stormed"], &["stormfront"], &["stronghold"], - &["story"], + &["strongly"], + &["strongly"], + &["store"], + &["stored"], + &["stores"], + &["storing"], + &["storage"], + &["story", "destroy"], &["storyline"], &["storylines"], &["storytelling"], @@ -11993,9 +23270,12 @@ static WORD_STRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_STRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ad")], - values: &[&["strand"]], - range: 2..=2, + 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 { @@ -12007,131 +23287,191 @@ pub static WORD_STRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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("rngification"), ], values: &[ &["straight"], &["straighten"], + &["straightens"], &["straightforward"], + &["straights"], &["strains"], &["strictly"], + &["strictly"], + &["stricter"], + &["stricter"], + &["strictest"], &["strictest"], &["strictly"], &["striker"], &["strikers"], + &["string"], + &["stringification"], + &["stringifying"], &["strikingly"], &["stringent"], + &["stringified"], &["stringent"], + &["strings"], + &["stripped"], + &["stripped"], + &["stringification"], ], - range: 3..=11, + range: 1..=12, }; static WORD_STRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_STRE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_STRE_CHILDREN), value: None, }; -pub static WORD_STRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aching"), - dictgen::InsensitiveStr::Ascii("amade"), - dictgen::InsensitiveStr::Ascii("amare"), - dictgen::InsensitiveStr::Ascii("amd"), - dictgen::InsensitiveStr::Ascii("amear"), - dictgen::InsensitiveStr::Ascii("ames"), - dictgen::InsensitiveStr::Ascii("amos"), - dictgen::InsensitiveStr::Ascii("amtrue"), - dictgen::InsensitiveStr::Ascii("amus"), - dictgen::InsensitiveStr::Ascii("amys"), - dictgen::InsensitiveStr::Ascii("chted"), - dictgen::InsensitiveStr::Ascii("chtes"), - dictgen::InsensitiveStr::Ascii("chting"), - dictgen::InsensitiveStr::Ascii("cthed"), - dictgen::InsensitiveStr::Ascii("cthes"), - dictgen::InsensitiveStr::Ascii("cthing"), - dictgen::InsensitiveStr::Ascii("emlining"), - dictgen::InsensitiveStr::Ascii("gnth"), - dictgen::InsensitiveStr::Ascii("gnthen"), - dictgen::InsensitiveStr::Ascii("gnthening"), - dictgen::InsensitiveStr::Ascii("gnths"), - dictgen::InsensitiveStr::Ascii("gth"), - dictgen::InsensitiveStr::Ascii("ichung"), - dictgen::InsensitiveStr::Ascii("ightened"), - dictgen::InsensitiveStr::Ascii("mear"), - dictgen::InsensitiveStr::Ascii("ngh"), - dictgen::InsensitiveStr::Ascii("nghen"), - dictgen::InsensitiveStr::Ascii("nghened"), - dictgen::InsensitiveStr::Ascii("nghening"), - dictgen::InsensitiveStr::Ascii("nght"), - dictgen::InsensitiveStr::Ascii("nghten"), - dictgen::InsensitiveStr::Ascii("nghtend"), - dictgen::InsensitiveStr::Ascii("nghtened"), - dictgen::InsensitiveStr::Ascii("nghtening"), - dictgen::InsensitiveStr::Ascii("nghtens"), - dictgen::InsensitiveStr::Ascii("ngsten"), - dictgen::InsensitiveStr::Ascii("ngtened"), - dictgen::InsensitiveStr::Ascii("ngtheing"), - dictgen::InsensitiveStr::Ascii("ngthes"), - dictgen::InsensitiveStr::Ascii("ngthin"), - dictgen::InsensitiveStr::Ascii("ngthining"), - dictgen::InsensitiveStr::Ascii("ngthn"), - dictgen::InsensitiveStr::Ascii("ngts"), - dictgen::InsensitiveStr::Ascii("nous"), - dictgen::InsensitiveStr::Ascii("ntgh"), - dictgen::InsensitiveStr::Ascii("ntghs"), - dictgen::InsensitiveStr::Ascii("oid"), - dictgen::InsensitiveStr::Ascii("ssade"), - dictgen::InsensitiveStr::Ascii("ssende"), - dictgen::InsensitiveStr::Ascii("ssers"), - dictgen::InsensitiveStr::Ascii("sss"), - dictgen::InsensitiveStr::Ascii("tchs"), - dictgen::InsensitiveStr::Ascii("tegically"), + 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: &[ - &["stretching"], - &["streamed"], - &["streamer"], - &["streamed"], - &["streamer"], - &["streams"], - &["streams"], - &["streamer"], - &["streams"], - &["streams"], - &["stretched"], - &["stretches"], - &["stretching"], - &["stretched"], - &["stretches"], - &["stretching"], - &["streamlining"], &["strength"], &["strengthen"], + &["strengthened"], &["strengthening"], + &["strength"], + &["strengthen"], + &["strengthen"], + &["strengthened"], + &["strengthening"], + &["strengthen"], &["strengths"], - &["strength"], - &["stretching"], - &["straightened"], - &["streamer"], - &["strength"], - &["strengthen"], - &["strengthened"], - &["strengthening"], - &["strength"], - &["strengthen"], - &["strengthen"], - &["strengthened"], - &["strengthening"], - &["strengthen"], &["strengthen"], &["strengthened"], &["strengthening"], @@ -12143,100 +23483,381 @@ pub static WORD_STRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["strenuous"], &["strength"], &["strengths"], - &["steroid"], - &["stressed"], - &["stressed"], - &["stresses"], - &["stresses"], - &["stretches"], - &["strategically"], + &["strength"], ], - range: 3..=9, + range: 2..=8, }; -static WORD_STRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_STRA_CHILDREN), +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_STRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_STREI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("degies"), - dictgen::InsensitiveStr::Ascii("degy"), - dictgen::InsensitiveStr::Ascii("gegically"), - dictgen::InsensitiveStr::Ascii("getic"), - dictgen::InsensitiveStr::Ascii("getically"), - dictgen::InsensitiveStr::Ascii("geties"), - dictgen::InsensitiveStr::Ascii("gety"), - dictgen::InsensitiveStr::Ascii("ightden"), - dictgen::InsensitiveStr::Ascii("ighted"), - dictgen::InsensitiveStr::Ascii("ightend"), - dictgen::InsensitiveStr::Ascii("ightenend"), - dictgen::InsensitiveStr::Ascii("ightforeward"), - dictgen::InsensitiveStr::Ascii("ightforwad"), - dictgen::InsensitiveStr::Ascii("ightie"), - dictgen::InsensitiveStr::Ascii("ightin"), - dictgen::InsensitiveStr::Ascii("ightmen"), - dictgen::InsensitiveStr::Ascii("ightn"), - dictgen::InsensitiveStr::Ascii("ightned"), - dictgen::InsensitiveStr::Ascii("ightner"), - dictgen::InsensitiveStr::Ascii("ignt"), - dictgen::InsensitiveStr::Ascii("igntened"), - dictgen::InsensitiveStr::Ascii("igt"), - dictgen::InsensitiveStr::Ascii("igth"), - dictgen::InsensitiveStr::Ascii("igthen"), - dictgen::InsensitiveStr::Ascii("igthened"), - dictgen::InsensitiveStr::Ascii("igthforward"), - dictgen::InsensitiveStr::Ascii("ind"), - dictgen::InsensitiveStr::Ascii("ings"), - dictgen::InsensitiveStr::Ascii("itforward"), - dictgen::InsensitiveStr::Ascii("ngel"), - dictgen::InsensitiveStr::Ascii("ngeshit"), - dictgen::InsensitiveStr::Ascii("nget"), - dictgen::InsensitiveStr::Ascii("ngets"), - dictgen::InsensitiveStr::Ascii("nglove"), - dictgen::InsensitiveStr::Ascii("ngreal"), - dictgen::InsensitiveStr::Ascii("t"), - dictgen::InsensitiveStr::Ascii("tagically"), - dictgen::InsensitiveStr::Ascii("tagies"), - dictgen::InsensitiveStr::Ascii("tegems"), - dictgen::InsensitiveStr::Ascii("tegicaly"), - dictgen::InsensitiveStr::Ascii("tegice"), - dictgen::InsensitiveStr::Ascii("tegiclly"), - dictgen::InsensitiveStr::Ascii("tegis"), - dictgen::InsensitiveStr::Ascii("tegisch"), - dictgen::InsensitiveStr::Ascii("tegisk"), - dictgen::InsensitiveStr::Ascii("tegiske"), - dictgen::InsensitiveStr::Ascii("tgey"), - dictgen::InsensitiveStr::Ascii("tigically"), - dictgen::InsensitiveStr::Ascii("tled"), - dictgen::InsensitiveStr::Ascii("vation"), - dictgen::InsensitiveStr::Ascii("wbarry"), - dictgen::InsensitiveStr::Ascii("wbeary"), - dictgen::InsensitiveStr::Ascii("wbeery"), - dictgen::InsensitiveStr::Ascii("wberies"), - dictgen::InsensitiveStr::Ascii("wberrries"), - dictgen::InsensitiveStr::Ascii("wberrry"), - dictgen::InsensitiveStr::Ascii("wbery"), - dictgen::InsensitiveStr::Ascii("wbrary"), - dictgen::InsensitiveStr::Ascii("wbrerry"), - dictgen::InsensitiveStr::Ascii("wburries"), - dictgen::InsensitiveStr::Ascii("wburry"), + dictgen::InsensitiveStr::Ascii("chung"), + dictgen::InsensitiveStr::Ascii("ghtened"), + ], + values: &[&["stretching"], &["straightened"]], + range: 5..=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("thed"), + dictgen::InsensitiveStr::Ascii("thes"), + dictgen::InsensitiveStr::Ascii("thing"), + ], + values: &[ + &["stretch"], + &["stretched"], + &["stretches"], + &["stretching"], + &["stretched"], + &["stretches"], + &["stretching"], + &["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"), + ], + values: &[ + &["stretching"], + &["streamed"], + &["streamer"], + &["streamed"], + &["streamer"], + &["streams"], + &["stream"], + &["streamed"], + &["streaming"], + &["streams"], + &["streamer"], + &["streams"], + &["streams"], + &["stretched"], + ], + range: 2..=5, +}; + +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("ture"), + dictgen::InsensitiveStr::Ascii("tures"), + dictgen::InsensitiveStr::Ascii("utre"), + dictgen::InsensitiveStr::Ascii("utural"), + dictgen::InsensitiveStr::Ascii("uture"), + dictgen::InsensitiveStr::Ascii("utures"), + ], + values: &[ + &["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, + None, + 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: &[ - &["strategies"], - &["strategy"], &["strategically"], + &["strategies"], + &["strategies"], + &["strategically"], + &["strategies"], + &["strategically"], + &["strategies"], &["strategic"], - &["strategically"], + &["strategies"], &["strategies"], &["strategy"], + &["strategically"], + &["startled"], + ], + range: 3..=8, +}; + +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("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"], @@ -12252,41 +23873,62 @@ pub static WORD_STRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["straightforward"], &["strained"], &["strains"], + &["strains"], &["straightforward"], - &["strangle"], - &["strangest"], - &["strangest"], - &["strangest"], - &["strangle"], - &["strangle"], - &["start"], + ], + 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("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: &[ + &["strategy", "tragedy"], &["strategically"], - &["strategies"], - &["strategies"], - &["strategically"], - &["strategies"], - &["strategically"], - &["strategies"], + &["strategy"], &["strategic"], - &["strategies"], + &["strategically"], &["strategies"], &["strategy"], - &["strategically"], - &["startled"], - &["starvation"], - &["strawberry"], - &["strawberry"], - &["strawberry"], - &["strawberries"], - &["strawberries"], - &["strawberry"], - &["strawberry"], - &["strawberry"], - &["strawberry"], - &["strawberries"], - &["strawberry"], ], - range: 1..=12, + range: 3..=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 { @@ -12307,12 +23949,29 @@ static WORD_STO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_STO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("rise"), @@ -12325,18 +23984,36 @@ pub static WORD_STO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: &[ + &["stochastic"], + &["stochastic"], &["stockpile"], &["stockpile"], + &["store"], + &["stores"], &["stomach"], + &["stomped"], &["stormfront"], &["strong"], + &["stopped"], + &["stopping"], + &["stop"], + &["stopped"], + &["stopping"], + &["stops"], &["story"], - &["storeys"], + &["storage"], + &["storable"], + &["storage"], + &["stream"], + &["storable"], + &["storing"], + &["storeys", "storeys", "stores"], &["storylines"], &["stories"], &["stormed"], @@ -12348,6 +24025,7 @@ pub static WORD_STO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["strongest"], &["stormfront"], &["stronghold"], + &["storeys", "storeys"], &["storytelling"], &["storytelling"], &["story"], @@ -12355,6 +24033,20 @@ pub static WORD_STO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -12364,11 +24056,20 @@ pub static WORD_STL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["stylish"]], - range: 2..=5, + values: &[ + &["stalker"], + &["stalkers"], + &["style"], + &["style"], + &["styles"], + &["stylish"], + ], + range: 1..=5, }; static WORD_STI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12384,6 +24085,9 @@ pub static WORD_STI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -12402,12 +24106,18 @@ pub static WORD_STI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("mulents"), dictgen::InsensitiveStr::Ascii("mulli"), dictgen::InsensitiveStr::Ascii("ngent"), + 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"], @@ -12416,6 +24126,9 @@ pub static WORD_STI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["stitched"], &["stitches"], &["stitching"], + &["stiffening"], + &["sticky"], + &["still"], &["stylus"], &["stimulants"], &["stimulated"], @@ -12434,14 +24147,20 @@ pub static WORD_STI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["stimulants"], &["stimuli"], &["stringent"], + &["stripped"], &["stirring"], &["striker"], &["strikers"], + &["string"], + &["strings"], + &["stir"], &["stirring"], &["stirs"], &["stitches"], + &["stick"], + &["sticks"], ], - range: 3..=8, + range: 1..=8, }; static WORD_STE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12464,7 +24183,13 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("eleries"), dictgen::InsensitiveStr::Ascii("eles"), 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"), @@ -12479,6 +24204,7 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -12509,7 +24235,13 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["steelers"], &["steelers"], &["stealthy"], + &["strength"], &["steroid"], + &["stream"], + &["streamed"], + &["streamer"], + &["streaming"], + &["streams"], &["stereotype"], &["stereotypical"], &["stereotypes"], @@ -12524,6 +24256,7 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["stereotyping"], &["sterile"], &["sterile"], + &["stereo"], &["steroids"], &["stereotype"], &["stereotypes"], @@ -12540,7 +24273,32 @@ pub static WORD_STE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["stereotypical"], &["stereotyping"], ], - range: 4..=10, + 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"), + ], + values: &[&["standard"], &["standards"]], + range: 5..=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 { @@ -12551,9 +24309,9 @@ static WORD_STA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ None, Some(&WORD_STAB_NODE), - None, + Some(&WORD_STAC_NODE), Some(&WORD_STAD_NODE), - None, + Some(&WORD_STAE_NODE), None, Some(&WORD_STAG_NODE), None, @@ -12571,12 +24329,23 @@ static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_STAT_NODE), Some(&WORD_STAU_NODE), None, - 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("k")], + values: &[&["stalk"]], + range: 1..=1, +}; + static WORD_STAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_STAU_CHILDREN), value: None, @@ -12584,13 +24353,22 @@ static WORD_STAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["saturation"], &["saturday"], &["saturdays"], &["statues"]], - range: 3..=6, + values: &[ + &["stalk"], + &["saturation"], + &["saturday"], + &["saturdays"], + &["status"], + &["statues"], + ], + range: 1..=6, }; static WORD_STAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12600,8 +24378,19 @@ static WORD_STAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_STAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("amenet"), + dictgen::InsensitiveStr::Ascii("amenets"), dictgen::InsensitiveStr::Ascii("eman"), + dictgen::InsensitiveStr::Ascii("emanet"), dictgen::InsensitiveStr::Ascii("ememts"), + dictgen::InsensitiveStr::Ascii("emen"), + dictgen::InsensitiveStr::Ascii("emenet"), + dictgen::InsensitiveStr::Ascii("emenets"), + dictgen::InsensitiveStr::Ascii("emet"), + dictgen::InsensitiveStr::Ascii("emnts"), + dictgen::InsensitiveStr::Ascii("i"), + dictgen::InsensitiveStr::Ascii("icly"), + dictgen::InsensitiveStr::Ascii("ictic"), dictgen::InsensitiveStr::Ascii("ictics"), dictgen::InsensitiveStr::Ascii("icts"), dictgen::InsensitiveStr::Ascii("ionair"), @@ -12610,10 +24399,15 @@ pub static WORD_STAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ionerad"), dictgen::InsensitiveStr::Ascii("ionnary"), dictgen::InsensitiveStr::Ascii("iony"), + dictgen::InsensitiveStr::Ascii("isfied"), + dictgen::InsensitiveStr::Ascii("isfies"), + dictgen::InsensitiveStr::Ascii("isfy"), + dictgen::InsensitiveStr::Ascii("isfying"), dictgen::InsensitiveStr::Ascii("isitc"), dictgen::InsensitiveStr::Ascii("isitcal"), dictgen::InsensitiveStr::Ascii("isitcally"), dictgen::InsensitiveStr::Ascii("isitcs"), + dictgen::InsensitiveStr::Ascii("isitics"), dictgen::InsensitiveStr::Ascii("iskt"), dictgen::InsensitiveStr::Ascii("istacally"), dictgen::InsensitiveStr::Ascii("istc"), @@ -12622,20 +24416,43 @@ pub static WORD_STAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("isticly"), dictgen::InsensitiveStr::Ascii("istisch"), dictgen::InsensitiveStr::Ascii("istisk"), + dictgen::InsensitiveStr::Ascii("itic"), + dictgen::InsensitiveStr::Ascii("itics"), dictgen::InsensitiveStr::Ascii("its"), + dictgen::InsensitiveStr::Ascii("menet"), + dictgen::InsensitiveStr::Ascii("menmt"), dictgen::InsensitiveStr::Ascii("ment"), + dictgen::InsensitiveStr::Ascii("ments"), + dictgen::InsensitiveStr::Ascii("rt"), dictgen::InsensitiveStr::Ascii("sit"), dictgen::InsensitiveStr::Ascii("sitical"), + dictgen::InsensitiveStr::Ascii("tistic"), dictgen::InsensitiveStr::Ascii("tues"), + dictgen::InsensitiveStr::Ascii("ubar"), dictgen::InsensitiveStr::Ascii("uer"), dictgen::InsensitiveStr::Ascii("uets"), + dictgen::InsensitiveStr::Ascii("up"), dictgen::InsensitiveStr::Ascii("use"), dictgen::InsensitiveStr::Ascii("user"), + dictgen::InsensitiveStr::Ascii("uss"), + dictgen::InsensitiveStr::Ascii("usses"), + dictgen::InsensitiveStr::Ascii("ustics"), dictgen::InsensitiveStr::Ascii("uts"), ], values: &[ - &["statesman"], + &["statement"], &["statements"], + &["statesman"], + &["statement"], + &["statements"], + &["statement"], + &["statement"], + &["statements"], + &["statement"], + &["statements"], + &["statuses"], + &["statically"], + &["statistic"], &["statistics"], &["statist"], &["stationary"], @@ -12644,10 +24461,15 @@ pub static WORD_STAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["stationed"], &["stationary"], &["stationary"], + &["satisfied"], + &["satisfies"], + &["satisfy"], + &["satisfying"], &["statistic"], &["statistical"], &["statistically"], &["statistics"], + &["statistics"], &["statist"], &["statistically"], &["statistic"], @@ -12656,18 +24478,30 @@ pub static WORD_STAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["statistical"], &["statistics"], &["statistics"], + &["statistic"], + &["statistics"], &["statist"], &["statement"], + &["statement"], + &["statement"], + &["statements"], + &["start"], &["statist"], &["statistical"], + &["statistic"], &["statutes"], + &["statusbar"], &["stature"], &["statutes"], + &["startup"], &["statutes"], &["stature"], + &["status"], + &["statuses"], + &["statistics"], &["statutes"], ], - range: 3..=9, + range: 1..=9, }; static WORD_STAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12677,6 +24511,9 @@ static WORD_STAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("dardized"), dictgen::InsensitiveStr::Ascii("ight"), dictgen::InsensitiveStr::Ascii("ighten"), @@ -12686,20 +24523,32 @@ pub static WORD_STAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("tsup"), + 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"], &["standardized"], &["straight"], &["straighten"], @@ -12709,20 +24558,29 @@ pub static WORD_STAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["strains"], &["startled"], &["starvation"], + &["started"], &["startled"], &["strategic"], &["strategically"], &["strategies"], &["strategy"], &["startled"], + &["started"], + &["starting"], + &["starting"], + &["startlistening"], &["startled"], + &["starting"], + &["startups"], + &["starting"], &["startups"], &["startups"], + &["startup"], &["startups"], &["strawberries"], &["strawberry"], ], - range: 3..=11, + range: 1..=11, }; static WORD_STAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12745,26 +24603,62 @@ pub static WORD_STAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ 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("darized"), 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("derdized"), + dictgen::InsensitiveStr::Ascii("dtard"), + dictgen::InsensitiveStr::Ascii("dy"), dictgen::InsensitiveStr::Ascii("gant"), dictgen::InsensitiveStr::Ascii("ge"), + dictgen::InsensitiveStr::Ascii("p"), ], values: &[ &["stances"], &["stances"], + &["standalone"], + &["standard"], + &["standard"], &["standards"], &["standardized"], + &["standards"], + &["standard"], + &["standard"], + &["standards"], + &["standardisation"], + &["standardiser"], + &["standardised"], + &["standardization"], + &["standardizer"], + &["standardized"], + &["standards"], + &["standard"], &["standby"], &["standby"], &["standardized"], + &["standard"], + &["standby", "sandy", "standee"], &["stagnant"], &["strange"], + &["stamp"], ], - range: 2..=8, + range: 1..=11, }; static WORD_STAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12790,12 +24684,13 @@ static WORD_STAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["stalkers"], &["stalker"], &["stalkers"]], - range: 3..=4, + values: &[&["stalactite"], &["stalkers"], &["stalker"], &["stalkers"]], + range: 3..=6, }; static WORD_STAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12826,12 +24721,25 @@ static WORD_STAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ons"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tions"), + ], + values: &[ + &["statically"], + &["stadium"], + &["stadiums"], + &["stainless"], + &["station"], + &["stations"], + &["station"], + &["stations"], ], - values: &[&["stadium"], &["stadiums"], &["stainless"], &["station"]], range: 2..=5, }; @@ -12856,6 +24764,17 @@ pub static WORD_STAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -12864,11 +24783,45 @@ static WORD_STAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_STAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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("uim"), dictgen::InsensitiveStr::Ascii("uims"), ], - values: &[&["stadiums"], &["stadium"], &["stadiums"]], - range: 3..=4, + values: &[ + &["stadiums"], + &["standard"], + &["standardisation"], + &["standardised"], + &["standardising"], + &["standardization"], + &["standardized"], + &["standardizing"], + &["standards"], + &["stadium"], + &["stadiums"], + ], + range: 3..=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("kk"), + ], + values: &[&["stack"], &["stack"]], + range: 1..=2, }; static WORD_STAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12878,28 +24831,50 @@ static WORD_STAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_STAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("alization"), dictgen::InsensitiveStr::Ascii("elized"), dictgen::InsensitiveStr::Ascii("ilizare"), dictgen::InsensitiveStr::Ascii("ilizied"), dictgen::InsensitiveStr::Ascii("ilizier"), dictgen::InsensitiveStr::Ascii("ilizies"), + 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"], &["stabilize"], &["stabilize"], &["stabilize"], &["stabilize"], - &["stabilized"], - &["stabilize"], &["stability"], &["stabilized"], + &["stabilize"], + &["stability"], + &["stabilization"], + &["stabilize"], + &["stabilized"], ], - range: 5..=7, + range: 4..=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("ee"), + dictgen::InsensitiveStr::Ascii("ome"), + ], + values: &[&["see"], &["some"]], + range: 2..=3, }; static WORD_SR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12909,28 +24884,80 @@ static WORD_SR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("ting"), + dictgen::InsensitiveStr::Ascii("tings"), + dictgen::InsensitiveStr::Ascii("tructure"), + 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"], - &["sriracha"], + &["scrollbar"], + &["source"], &["sprouts"], &["sriracha"], + &["string", "sorting"], + &["strings"], + &["structure"], + &["structure"], + &["structures"], + &["shrunk"], + &["shrunken"], + &["shrunken"], &["syracuse"], &["syrians"], &["syringe"], ], - range: 5..=7, + range: 2..=11, }; static WORD_SQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -12940,11 +24967,19 @@ static WORD_SQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -12952,9 +24987,12 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -12969,6 +25007,7 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("uirtel"), dictgen::InsensitiveStr::Ascii("uishey"), dictgen::InsensitiveStr::Ascii("uishly"), + dictgen::InsensitiveStr::Ascii("urared"), dictgen::InsensitiveStr::Ascii("uritle"), dictgen::InsensitiveStr::Ascii("urriel"), dictgen::InsensitiveStr::Ascii("urriels"), @@ -12976,11 +25015,19 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("usihy"), ], values: &[ + &["square"], + &["squared"], + &["squares"], + &["squash"], + &["squashed"], + &["squashing"], &["squadron"], &["square"], + &["squared"], &["squarely"], &["squares"], &["squeaky"], + &["sequence"], &["squirtle"], &["squishy"], &["squadron"], @@ -12988,9 +25035,12 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["squares"], &["squarely"], &["squarely"], + &["squashing"], &["squeaky"], &["squeaky"], - &["squirtle"], + &["sequence"], + &["squirtle", "squirrel"], + &["squirrel"], &["squirrel"], &["squirtle"], &["squirrels"], @@ -13005,13 +25055,14 @@ pub static WORD_SQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["squirtle"], &["squishy"], &["squishy"], + &["squared"], &["squirtle"], &["squirrel"], &["squirrels"], &["squirtle"], &["squishy"], ], - range: 4..=9, + range: 3..=9, }; static WORD_SP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13022,7 +25073,7 @@ static WORD_SP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_SPA_NODE), None, - None, + Some(&WORD_SPC_NODE), None, Some(&WORD_SPE_NODE), None, @@ -13038,9 +25089,9 @@ static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SPP_NODE), None, Some(&WORD_SPR_NODE), - None, - None, - None, + Some(&WORD_SPS_NODE), + Some(&WORD_SPT_NODE), + Some(&WORD_SPU_NODE), None, Some(&WORD_SPW_NODE), None, @@ -13062,6 +25113,45 @@ pub static WORD_SPW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 4..=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("aces"), + ], + values: &[&["space"], &["spaces"]], + range: 3..=4, +}; + static WORD_SPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_SPR_CHILDREN), value: None, @@ -13082,8 +25172,16 @@ pub static WORD_SPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -13097,6 +25195,7 @@ pub static WORD_SPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("iritual"), dictgen::InsensitiveStr::Ascii("itual"), dictgen::InsensitiveStr::Ascii("oels"), + dictgen::InsensitiveStr::Ascii("oon"), dictgen::InsensitiveStr::Ascii("otsmanship"), dictgen::InsensitiveStr::Ascii("outes"), ], @@ -13114,8 +25213,16 @@ pub static WORD_SPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["spreadsheets"], &["spreadsheet"], &["spreadsheets"], + &["spreadsheet"], + &["spreadsheets"], + &["speech"], + &["special"], + &["specialized"], + &["specially"], &["spread"], &["spreadsheet"], + &["spreadsheet"], + &["sprintf"], &["springfield"], &["springfield"], &["springfield"], @@ -13129,6 +25236,7 @@ pub static WORD_SPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["spiritual"], &["spiritual"], &["sproles"], + &["spoon"], &["sportsmanship"], &["sprouts"], ], @@ -13141,9 +25249,23 @@ static WORD_SPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("eches")], - values: &[&["speeches"]], - range: 5..=5, + 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 { @@ -13165,6 +25287,7 @@ pub static WORD_SPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -13197,6 +25320,8 @@ pub static WORD_SPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -13221,6 +25346,7 @@ pub static WORD_SPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sponsored"], &["sponsor"], &["sponsored"], + &["sponsors"], &["sponsorship"], &["sponsored"], &["sponsors"], @@ -13253,6 +25379,8 @@ pub static WORD_SPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sponsored"], &["spoonfuls"], &["sopranos"], + &["sporadic"], + &["spurious"], &["sproles"], &["sportsmanship"], &["sportsmanship"], @@ -13277,17 +25405,33 @@ pub static WORD_SPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("aton"), dictgen::InsensitiveStr::Ascii("atooon"), dictgen::InsensitiveStr::Ascii("eling"), + dictgen::InsensitiveStr::Ascii("ig"), + dictgen::InsensitiveStr::Ascii("igs"), + dictgen::InsensitiveStr::Ascii("iitting"), + dictgen::InsensitiveStr::Ascii("ite"), + 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"], + &["splitting"], + &["split", "splits", "splice"], + &["splitting"], &["splinter"], + &["split"], + &["splitting"], &["splitter"], + &["splitting"], ], - range: 4..=6, + range: 2..=7, }; static WORD_SPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13297,10 +25441,15 @@ static WORD_SPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cific"), + dictgen::InsensitiveStr::Ascii("le"), dictgen::InsensitiveStr::Ascii("lnter"), dictgen::InsensitiveStr::Ascii("ltter"), + dictgen::InsensitiveStr::Ascii("ltting"), dictgen::InsensitiveStr::Ascii("ndel"), dictgen::InsensitiveStr::Ascii("ndrel"), + dictgen::InsensitiveStr::Ascii("nlcok"), + dictgen::InsensitiveStr::Ascii("nock"), dictgen::InsensitiveStr::Ascii("ritd"), dictgen::InsensitiveStr::Ascii("rites"), dictgen::InsensitiveStr::Ascii("ritis"), @@ -13319,10 +25468,15 @@ pub static WORD_SPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tirually"), ], values: &[ + &["specific"], + &["spite", "spiral"], &["splinter"], &["splitter"], + &["splitting"], &["spindle"], &["spindle"], + &["spinlock"], + &["spinlock"], &["spirited"], &["spirits"], &["spirits"], @@ -13340,7 +25494,7 @@ pub static WORD_SPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["spiritually"], &["spiritually"], ], - range: 4..=10, + range: 2..=10, }; static WORD_SPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13366,9 +25520,9 @@ static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_SPEA_NODE), None, Some(&WORD_SPEC_NODE), - None, + Some(&WORD_SPED_NODE), Some(&WORD_SPEE_NODE), - None, + Some(&WORD_SPEF_NODE), None, Some(&WORD_SPEH_NODE), Some(&WORD_SPEI_NODE), @@ -13378,7 +25532,7 @@ static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_SPEN_NODE), None, - None, + Some(&WORD_SPEP_NODE), None, Some(&WORD_SPER_NODE), Some(&WORD_SPES_NODE), @@ -13397,9 +25551,19 @@ static WORD_SPEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SPEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ialisation")], - values: &[&["specialisation"]], - range: 10..=10, + keys: &[ + dictgen::InsensitiveStr::Ascii("ialisation"), + dictgen::InsensitiveStr::Ascii("ific"), + dictgen::InsensitiveStr::Ascii("ified"), + dictgen::InsensitiveStr::Ascii("ify"), + ], + values: &[ + &["specialisation", "specialisation"], + &["specific"], + &["specified"], + &["specify"], + ], + range: 3..=10, }; static WORD_SPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13420,12 +25584,30 @@ static WORD_SPES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ifically"), dictgen::InsensitiveStr::Ascii("ification"), dictgen::InsensitiveStr::Ascii("ifications"), + dictgen::InsensitiveStr::Ascii("ified"), + dictgen::InsensitiveStr::Ascii("ify"), ], - values: &[&["specifically"], &["specification"], &["specifications"]], - range: 8..=10, + values: &[ + &["special"], + &["specially", "especially"], + &["special"], + &["specially", "especially"], + &["specialisation"], + &["specifically"], + &["specification"], + &["specifications"], + &["specified"], + &["specify"], + ], + range: 3..=10, }; static WORD_SPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13434,9 +25616,38 @@ static WORD_SPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("matozoan")], - values: &[&["spermatozoon"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("ate"), + dictgen::InsensitiveStr::Ascii("ately"), + dictgen::InsensitiveStr::Ascii("matozoan"), + ], + values: &[&["separate"], &["separately"], &["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"), + ], + values: &[ + &["separate"], + &["separated"], + &["separating"], + &["separation"], + &["separator"], + &["spec"], + ], + range: 1..=7, }; static WORD_SPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13457,11 +25668,18 @@ static WORD_SPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"]], - range: 3..=4, + values: &[ + &["spelling"], + &["spelling"], + &["spelling"], + &["spellchecking"], + ], + range: 3..=9, }; static WORD_SPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13476,6 +25694,10 @@ pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -13483,6 +25705,10 @@ pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["specially"], &["specials"], &["species"], + &["specified"], + &["specific"], + &["specified"], + &["specify"], ], range: 3..=6, }; @@ -13501,6 +25727,921 @@ pub static WORD_SPEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic range: 3..=5, }; +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, @@ -13508,12 +26649,45 @@ static WORD_SPEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["speeches"], &["speeches"], &["speeches"]], - range: 3..=6, + 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 { @@ -13532,7 +26706,7 @@ static WORD_SPEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_SPECI_NODE), None, - None, + Some(&WORD_SPECK_NODE), None, None, None, @@ -13562,6 +26736,8 @@ pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -13573,12 +26749,14 @@ pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["speculation"], &["speculation"], &["speculative"], + &["specifies"], + &["specify"], &["speculative"], &["speculative"], &["speculative"], &["speculation"], ], - range: 4..=7, + range: 2..=7, }; static WORD_SPECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13609,7 +26787,10 @@ pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -13632,7 +26813,10 @@ pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["spectral"], &["spectral"], &["spectral"], - &["aspects"], + &["aspects", "expects", "specs"], + &["spectacular"], + &["spectacularly"], + &["spectrum"], &["spectrum"], ], range: 1..=9, @@ -13649,79 +26833,355 @@ pub static WORD_SPECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di range: 3..=3, }; -static WORD_SPECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SPECI_CHILDREN), +static WORD_SPECK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SPECK_CHILDREN), value: None, }; -pub static WORD_SPECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_SPECK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("tor")], + values: &[&["specter", "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("aal"), - dictgen::InsensitiveStr::Ascii("ales"), - dictgen::InsensitiveStr::Ascii("alication"), - dictgen::InsensitiveStr::Ascii("alice"), - dictgen::InsensitiveStr::Ascii("aliced"), - dictgen::InsensitiveStr::Ascii("alices"), - dictgen::InsensitiveStr::Ascii("alied"), - dictgen::InsensitiveStr::Ascii("alies"), - dictgen::InsensitiveStr::Ascii("alis"), - dictgen::InsensitiveStr::Ascii("alistes"), - dictgen::InsensitiveStr::Ascii("alites"), - dictgen::InsensitiveStr::Ascii("alits"), - dictgen::InsensitiveStr::Ascii("alizaiton"), - dictgen::InsensitiveStr::Ascii("alizare"), - dictgen::InsensitiveStr::Ascii("alizate"), - dictgen::InsensitiveStr::Ascii("alizaton"), - dictgen::InsensitiveStr::Ascii("alizeds"), - dictgen::InsensitiveStr::Ascii("alizied"), - dictgen::InsensitiveStr::Ascii("allist"), - dictgen::InsensitiveStr::Ascii("allity"), - dictgen::InsensitiveStr::Ascii("allize"), - dictgen::InsensitiveStr::Ascii("allized"), - dictgen::InsensitiveStr::Ascii("allly"), - dictgen::InsensitiveStr::Ascii("allty"), - dictgen::InsensitiveStr::Ascii("alops"), - dictgen::InsensitiveStr::Ascii("alsts"), - dictgen::InsensitiveStr::Ascii("alt"), - dictgen::InsensitiveStr::Ascii("altys"), - dictgen::InsensitiveStr::Ascii("aly"), - dictgen::InsensitiveStr::Ascii("alz"), - dictgen::InsensitiveStr::Ascii("alzed"), - dictgen::InsensitiveStr::Ascii("alzes"), - dictgen::InsensitiveStr::Ascii("alzied"), - dictgen::InsensitiveStr::Ascii("as"), - dictgen::InsensitiveStr::Ascii("atly"), - dictgen::InsensitiveStr::Ascii("fcally"), - dictgen::InsensitiveStr::Ascii("fcation"), - dictgen::InsensitiveStr::Ascii("fed"), - dictgen::InsensitiveStr::Ascii("ficaiton"), - dictgen::InsensitiveStr::Ascii("ficaitons"), - dictgen::InsensitiveStr::Ascii("ficaly"), - dictgen::InsensitiveStr::Ascii("ficato"), - dictgen::InsensitiveStr::Ascii("ficatons"), - dictgen::InsensitiveStr::Ascii("fices"), - dictgen::InsensitiveStr::Ascii("ficies"), - dictgen::InsensitiveStr::Ascii("fiing"), - dictgen::InsensitiveStr::Ascii("fikation"), dictgen::InsensitiveStr::Ascii("fing"), - dictgen::InsensitiveStr::Ascii("fiy"), - dictgen::InsensitiveStr::Ascii("fiying"), - dictgen::InsensitiveStr::Ascii("fiyng"), - dictgen::InsensitiveStr::Ascii("laized"), - dictgen::InsensitiveStr::Ascii("liast"), - dictgen::InsensitiveStr::Ascii("liazation"), - dictgen::InsensitiveStr::Ascii("liazed"), - dictgen::InsensitiveStr::Ascii("man"), - dictgen::InsensitiveStr::Ascii("mine"), - dictgen::InsensitiveStr::Ascii("mines"), - dictgen::InsensitiveStr::Ascii("sl"), + 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("ized"), ], values: &[ - &["special"], - &["specials"], + &["specialize"], + &["specialists"], &["specialization"], &["specialize"], &["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("ed"), + dictgen::InsensitiveStr::Ascii("fc"), + dictgen::InsensitiveStr::Ascii("fed"), + ], + values: &[&["specified"], &["specific"], &["specified"]], + range: 2..=3, +}; + +static WORD_SPECIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SPECIF_CHILDREN), + value: None, +}; + +pub static WORD_SPECIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("actions"), + dictgen::InsensitiveStr::Ascii("c"), + dictgen::InsensitiveStr::Ascii("cally"), + dictgen::InsensitiveStr::Ascii("cation"), + dictgen::InsensitiveStr::Ascii("cations"), + dictgen::InsensitiveStr::Ascii("cied"), + dictgen::InsensitiveStr::Ascii("clly"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("fic"), + dictgen::InsensitiveStr::Ascii("fically"), + dictgen::InsensitiveStr::Ascii("ially"), + dictgen::InsensitiveStr::Ascii("icaiton"), + dictgen::InsensitiveStr::Ascii("icaitons"), + dictgen::InsensitiveStr::Ascii("icallly"), + dictgen::InsensitiveStr::Ascii("icaly"), + dictgen::InsensitiveStr::Ascii("icated"), + dictgen::InsensitiveStr::Ascii("icateion"), + dictgen::InsensitiveStr::Ascii("icatin"), + dictgen::InsensitiveStr::Ascii("icato"), + dictgen::InsensitiveStr::Ascii("icaton"), + dictgen::InsensitiveStr::Ascii("icatons"), + dictgen::InsensitiveStr::Ascii("iced"), + dictgen::InsensitiveStr::Ascii("ices"), + dictgen::InsensitiveStr::Ascii("ich"), + dictgen::InsensitiveStr::Ascii("icially"), + dictgen::InsensitiveStr::Ascii("iciation"), + dictgen::InsensitiveStr::Ascii("iciations"), + dictgen::InsensitiveStr::Ascii("icically"), + dictgen::InsensitiveStr::Ascii("icied"), + dictgen::InsensitiveStr::Ascii("icies"), + dictgen::InsensitiveStr::Ascii("icl"), + dictgen::InsensitiveStr::Ascii("icly"), + dictgen::InsensitiveStr::Ascii("iction"), + dictgen::InsensitiveStr::Ascii("ictions"), + dictgen::InsensitiveStr::Ascii("icy"), + dictgen::InsensitiveStr::Ascii("id"), + dictgen::InsensitiveStr::Ascii("iing"), + dictgen::InsensitiveStr::Ascii("ikation"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("iy"), + dictgen::InsensitiveStr::Ascii("iying"), + dictgen::InsensitiveStr::Ascii("iyng"), + dictgen::InsensitiveStr::Ascii("ric"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("yed"), + dictgen::InsensitiveStr::Ascii("yied"), + dictgen::InsensitiveStr::Ascii("yig"), + dictgen::InsensitiveStr::Ascii("yinhg"), + ], + values: &[ + &["specifications"], + &["specific"], + &["specifically"], + &["specification"], + &["specifications"], + &["specified"], + &["specifically"], + &["specified"], + &["specific"], + &["specifically"], + &["specifically"], + &["specifications"], + &["specification"], + &["specifically"], + &["specifically"], + &["specified"], + &["specification"], + &["specification"], + &["specification"], + &["specification"], + &["specifications"], + &["specified"], + &["specifics", "specifies"], + &["specify", "specific"], + &["specifically"], + &["specification"], + &["specifications"], + &["specifically"], + &["specified"], + &["specifics"], + &["specific"], + &["specifically"], + &["specification"], + &["specifications"], + &["specify", "specificity", "specifically"], + &["specified"], + &["specifying"], + &["specification"], + &["specifying"], + &["specify"], + &["specifying"], + &["specifying"], + &["specific"], + &["specify"], + &["specified"], + &["specified"], + &["specifying"], + &["specifying"], + ], + range: 1..=9, +}; + +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("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("listes"), + dictgen::InsensitiveStr::Ascii("lites"), + dictgen::InsensitiveStr::Ascii("lits"), + dictgen::InsensitiveStr::Ascii("litzed"), + dictgen::InsensitiveStr::Ascii("lizaiton"), + dictgen::InsensitiveStr::Ascii("lizare"), + dictgen::InsensitiveStr::Ascii("lizate"), + dictgen::InsensitiveStr::Ascii("lizaton"), + dictgen::InsensitiveStr::Ascii("lizeds"), + dictgen::InsensitiveStr::Ascii("lizied"), + 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"], + &["specials"], + &["specialization"], + &["specialize"], + &["specialized", "specialised"], &["specializes"], &["specialized"], &["specializes"], @@ -13729,6 +27189,7 @@ pub static WORD_SPECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["specialists"], &["specializes"], &["specials"], + &["specialized", "specialized"], &["specialization"], &["specialize"], &["specialize"], @@ -13738,7 +27199,7 @@ pub static WORD_SPECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["specialist"], &["specially"], &["specialize"], - &["specialized"], + &["specialized", "specialized"], &["specially"], &["specially"], &["specials"], @@ -13752,32 +27213,8 @@ pub static WORD_SPECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["specialized"], &["specials"], &["specialty"], - &["specifically"], - &["specification"], - &["specified"], - &["specifications"], - &["specification"], - &["specifically"], - &["specification"], - &["specifications"], - &["specifics"], - &["specifics"], - &["specifying"], - &["specification"], - &["specifying"], - &["specify"], - &["specifying"], - &["specifying"], - &["specialize"], - &["specialists"], - &["specialization"], - &["specialize"], - &["specimen"], - &["specimen"], - &["specimen"], - &["specials"], ], - range: 2..=9, + range: 1..=8, }; static WORD_SPECF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13786,9 +27223,31 @@ static WORD_SPECF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_SPECF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ic")], - values: &[&["specific"]], - range: 2..=2, + keys: &[ + dictgen::InsensitiveStr::Ascii("ic"), + dictgen::InsensitiveStr::Ascii("ically"), + dictgen::InsensitiveStr::Ascii("ication"), + dictgen::InsensitiveStr::Ascii("ications"), + dictgen::InsensitiveStr::Ascii("ied"), + dictgen::InsensitiveStr::Ascii("ield"), + dictgen::InsensitiveStr::Ascii("ies"), + dictgen::InsensitiveStr::Ascii("iied"), + dictgen::InsensitiveStr::Ascii("y"), + dictgen::InsensitiveStr::Ascii("ying"), + ], + values: &[ + &["specific"], + &["specifically"], + &["specification"], + &["specifications"], + &["specified"], + &["specified"], + &["specifies"], + &["specified"], + &["specify"], + &["specifying"], + ], + range: 1..=8, }; static WORD_SPECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13797,9 +27256,12 @@ static WORD_SPECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_SPECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("min")], - values: &[&["specimen"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("fied"), + dictgen::InsensitiveStr::Ascii("min"), + ], + values: &[&["specified"], &["specimen"]], + range: 3..=4, }; static WORD_SPECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13843,9 +27305,42 @@ static WORD_SPEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SPEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ch")], - values: &[&["speech"]], - range: 2..=2, + keys: &[ + dictgen::InsensitiveStr::Ascii("ch"), + dictgen::InsensitiveStr::Ascii("cial"), + dictgen::InsensitiveStr::Ascii("rator"), + dictgen::InsensitiveStr::Ascii("rators"), + ], + values: &[ + &["speech"], + &["special", "spacial"], + &["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("ecified"), + dictgen::InsensitiveStr::Ascii("ial"), + dictgen::InsensitiveStr::Ascii("ific"), + dictgen::InsensitiveStr::Ascii("ifies"), + ], + values: &[ + &["space"], + &["specified"], + &["special"], + &["specific"], + &["specifies"], + ], + range: 2..=7, }; static WORD_SPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13857,9 +27352,16 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("cebr"), dictgen::InsensitiveStr::Ascii("cegoat"), + dictgen::InsensitiveStr::Ascii("cific"), dictgen::InsensitiveStr::Ascii("cification"), + dictgen::InsensitiveStr::Ascii("cifics"), + dictgen::InsensitiveStr::Ascii("cified"), + dictgen::InsensitiveStr::Ascii("cifies"), 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"), @@ -13869,9 +27371,12 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("rately"), dictgen::InsensitiveStr::Ascii("rkel"), dictgen::InsensitiveStr::Ascii("rklie"), dictgen::InsensitiveStr::Ascii("rlking"), @@ -13881,17 +27386,30 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rtas"), dictgen::InsensitiveStr::Ascii("rtsn"), dictgen::InsensitiveStr::Ascii("ryed"), + 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"], + &["specifics"], + &["specified"], + &["specifies"], &["spaghetti"], &["spaghetti"], &["spaghetti"], + &["spaghetti"], + &["sphagnum"], + &["spaghetti"], &["spanish"], &["spanish"], &["splatoon"], @@ -13900,9 +27418,12 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["spammer"], &["spammed"], &["spammer"], + &["spanning"], &["spanish"], &["spanish"], &["spawned"], + &["separate"], + &["separately"], &["sparkle"], &["sparkle"], &["sparkling"], @@ -13912,11 +27433,17 @@ pub static WORD_SPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["spartans"], &["spartans"], &["sprayed"], + &["spawn"], + &["spawned"], &["spawned"], &["spawning"], &["spawning"], + &["spawning"], + &["spawning"], + &["spawn"], + &["spawns"], ], - range: 4..=10, + range: 1..=10, }; static WORD_SO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -13925,7 +27452,7 @@ static WORD_SO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_SOA_NODE), Some(&WORD_SOB_NODE), Some(&WORD_SOC_NODE), None, @@ -13935,24 +27462,35 @@ static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SOH_NODE), Some(&WORD_SOI_NODE), None, - None, + Some(&WORD_SOK_NODE), Some(&WORD_SOL_NODE), Some(&WORD_SOM_NODE), - None, - None, + Some(&WORD_SON_NODE), + Some(&WORD_SOO_NODE), Some(&WORD_SOP_NODE), None, Some(&WORD_SOR_NODE), - None, + Some(&WORD_SOS_NODE), Some(&WORD_SOT_NODE), Some(&WORD_SOU_NODE), Some(&WORD_SOV_NODE), - None, + 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, @@ -13961,6 +27499,7 @@ static WORD_SOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -13980,9 +27519,13 @@ pub static WORD_SOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -14002,8 +27545,11 @@ pub static WORD_SOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sovereignty"], &["sovereignty"], &["soviets"], + &["solve"], + &["solved"], + &["sovereign"], ], - range: 4..=9, + range: 2..=9, }; static WORD_SOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14013,10 +27559,15 @@ static WORD_SOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ce"), + dictgen::InsensitiveStr::Ascii("ces"), + 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("ndard"), dictgen::InsensitiveStr::Ascii("ndrtack"), dictgen::InsensitiveStr::Ascii("ndtracs"), dictgen::InsensitiveStr::Ascii("ndtrak"), @@ -14025,6 +27576,16 @@ pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ndtrakk"), dictgen::InsensitiveStr::Ascii("ndtraks"), dictgen::InsensitiveStr::Ascii("ntrack"), + dictgen::InsensitiveStr::Ascii("rcd"), + dictgen::InsensitiveStr::Ascii("rcde"), + dictgen::InsensitiveStr::Ascii("rcedrectory"), + 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"), @@ -14033,6 +27594,7 @@ pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -14049,10 +27611,15 @@ pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("veniers"), ], values: &[ + &["source"], + &["sources"], + &["source"], + &["sources"], &["sound"], &["sounds"], &["soundtrack"], - &["could"], + &["could", "should", "sold"], + &["soundcard"], &["soundtracks"], &["soundtracks"], &["soundtrack"], @@ -14061,6 +27628,16 @@ pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["soundtrack"], &["soundtracks"], &["soundtrack"], + &["sourced", "source"], + &["sourced", "source"], + &["sourcedirectory"], + &["sources", "source"], + &["sources", "source"], + &["source"], + &["source", "sure", "sore", "sour", "soured"], + &["sources", "sores", "sours", "soured"], + &["surrounding"], + &["sort", "south", "sour"], &["south"], &["southern"], &["southampton"], @@ -14069,6 +27646,7 @@ pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["southampton"], &["southampton"], &["southampton"], + &["southbridge"], &["southern"], &["southerners"], &["southerners"], @@ -14084,7 +27662,7 @@ pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["souvenir"], &["souvenirs"], ], - range: 2..=9, + range: 2..=11, }; static WORD_SOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14094,6 +27672,11 @@ static WORD_SOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ring"), dictgen::InsensitiveStr::Ascii("rmfront"), dictgen::InsensitiveStr::Ascii("ry"), dictgen::InsensitiveStr::Ascii("ryline"), @@ -14101,15 +27684,31 @@ pub static WORD_SOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("yr"), ], values: &[ + &["stored", "sorted"], + &["software"], + &["storage", "shortage"], + &["sorted", "stored"], + &["storing", "sorting"], &["stormfront"], - &["story"], + &["story", "sorry"], &["storyline"], &["storylines"], - &["satyr"], + &["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, @@ -14117,22 +27716,40 @@ static WORD_SOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("panos"), 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"], &["sopranos"], &["surrounding"], + &["sorting"], + &["sorting"], + &["sortlist"], + &["sorter"], + &["sorter"], + &["storage", "shortage"], + &["source", "spruce"], + &["sources", "spruces"], ], - range: 5..=8, + range: 2..=8, }; static WORD_SOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14144,6 +27761,7 @@ pub static WORD_SOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -14161,6 +27779,7 @@ pub static WORD_SOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sophisticated"], &["sophisticated"], &["sophisticated"], + &["sophisticated"], &["sophomore"], &["sophisticated"], &["sophomore"], @@ -14168,66 +27787,224 @@ pub static WORD_SOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=10, }; -static WORD_SOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SOM_CHILDREN), +static WORD_SOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SOO_CHILDREN), value: None, }; -pub static WORD_SOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_SOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aila"), - dictgen::InsensitiveStr::Ascii("alija"), - dictgen::InsensitiveStr::Ascii("ehtin"), - dictgen::InsensitiveStr::Ascii("ehting"), - dictgen::InsensitiveStr::Ascii("ehtings"), - dictgen::InsensitiveStr::Ascii("ene"), - dictgen::InsensitiveStr::Ascii("eoens"), - dictgen::InsensitiveStr::Ascii("eoneis"), - dictgen::InsensitiveStr::Ascii("eonelse"), - dictgen::InsensitiveStr::Ascii("eons"), - dictgen::InsensitiveStr::Ascii("ethibng"), - dictgen::InsensitiveStr::Ascii("ethign"), - dictgen::InsensitiveStr::Ascii("ethigng"), - dictgen::InsensitiveStr::Ascii("ethigns"), - dictgen::InsensitiveStr::Ascii("ethihng"), - dictgen::InsensitiveStr::Ascii("ethiing"), - dictgen::InsensitiveStr::Ascii("ethijng"), - dictgen::InsensitiveStr::Ascii("ethikng"), - dictgen::InsensitiveStr::Ascii("ethimng"), - dictgen::InsensitiveStr::Ascii("ethinbg"), - dictgen::InsensitiveStr::Ascii("ethines"), - dictgen::InsensitiveStr::Ascii("ethinfg"), - dictgen::InsensitiveStr::Ascii("ethingest"), - dictgen::InsensitiveStr::Ascii("ethingis"), - dictgen::InsensitiveStr::Ascii("ethinhg"), - dictgen::InsensitiveStr::Ascii("ethinig"), - dictgen::InsensitiveStr::Ascii("ethinkg"), - dictgen::InsensitiveStr::Ascii("ethinks"), - dictgen::InsensitiveStr::Ascii("ethinmg"), - dictgen::InsensitiveStr::Ascii("ethinng"), - dictgen::InsensitiveStr::Ascii("ethins"), - dictgen::InsensitiveStr::Ascii("ethintg"), - dictgen::InsensitiveStr::Ascii("ethiong"), - dictgen::InsensitiveStr::Ascii("ethis"), - dictgen::InsensitiveStr::Ascii("ethiung"), - dictgen::InsensitiveStr::Ascii("ethn"), - dictgen::InsensitiveStr::Ascii("etihn"), - dictgen::InsensitiveStr::Ascii("etinh"), - dictgen::InsensitiveStr::Ascii("oenes"), - dictgen::InsensitiveStr::Ascii("times"), - dictgen::InsensitiveStr::Ascii("where"), + dictgen::InsensitiveStr::Ascii("aside"), + dictgen::InsensitiveStr::Ascii("donim"), + dictgen::InsensitiveStr::Ascii("it"), + dictgen::InsensitiveStr::Ascii("p"), + dictgen::InsensitiveStr::Ascii("urce"), ], values: &[ - &["somalia"], - &["somalia"], + &["suicide"], + &["pseudonym"], + &["suet", "suit", "soot"], + &["soup", "scoop", "snoop", "soap"], + &["source"], + ], + range: 1..=5, +}; + +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("imes"), + ], + values: &[&["something"], &["something"], &["sometimes"]], + range: 4..=4, +}; + +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("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("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("were"), + dictgen::InsensitiveStr::Ascii("wher"), + dictgen::InsensitiveStr::Ascii("who"), + ], + values: &[ + &["somebody"], &["something"], &["something"], &["somethings"], + &["somewhat"], + &["somewhere"], + &["somehow"], + &["someone"], + &["someone"], + &["someones"], &["someone"], &["someones"], &["someones"], &["someones"], - &["someones"], + &["some"], + &["something"], &["something"], &["something"], &["something"], @@ -14236,31 +28013,56 @@ pub static WORD_SOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["something"], &["something"], &["somethin"], - &["something"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["somethings"], - &["something"], - &["somethings"], - &["something"], - &["something"], - &["something"], - &["something"], - &["someones"], &["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"], &["somewhere"], + &["somewhere"], + &["somehow"], ], - range: 3..=9, + 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 { @@ -14270,38 +28072,78 @@ static WORD_SOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("armutx"), dictgen::InsensitiveStr::Ascii("atary"), dictgen::InsensitiveStr::Ascii("deirs"), 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("idairty"), dictgen::InsensitiveStr::Ascii("idariety"), dictgen::InsensitiveStr::Ascii("iders"), dictgen::InsensitiveStr::Ascii("iditary"), + dictgen::InsensitiveStr::Ascii("ification"), dictgen::InsensitiveStr::Ascii("iliquy"), dictgen::InsensitiveStr::Ascii("itudine"), + dictgen::InsensitiveStr::Ascii("tion"), dictgen::InsensitiveStr::Ascii("uable"), + dictgen::InsensitiveStr::Ascii("um"), dictgen::InsensitiveStr::Ascii("utide"), + dictgen::InsensitiveStr::Ascii("veable"), + dictgen::InsensitiveStr::Ascii("wed"), ], values: &[ + &["solarmutex"], &["solitary"], &["soldiers"], &["solidarity"], &["soldiers"], &["solidly"], + &["solver", "solar", "solely"], &["solely"], + &["solve", "sold"], + &["solved"], + &["solver", "solder"], + &["solves"], + &["solving"], + &["solves"], &["solidarity"], &["solidarity"], &["soldiers"], &["solidarity"], + &["solidification"], &["soliloquy"], &["solitude"], + &["solution"], &["soluble"], + &["solemn"], &["solitude"], + &["solvable"], + &["solved"], ], - range: 2..=8, + 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 { @@ -14313,8 +28155,9 @@ pub static WORD_SOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("lders"), dictgen::InsensitiveStr::Ascii("ldly"), + dictgen::InsensitiveStr::Ascii("urce"), ], - values: &[&["soldiers"], &["solidly"]], + values: &[&["soldiers"], &["solidly"], &["source"]], range: 4..=5, }; @@ -14339,9 +28182,23 @@ static WORD_SOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ware")], - values: &[&["software"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("isticated"), + dictgen::InsensitiveStr::Ascii("tend"), + dictgen::InsensitiveStr::Ascii("twares"), + dictgen::InsensitiveStr::Ascii("twre"), + dictgen::InsensitiveStr::Ascii("ware"), + dictgen::InsensitiveStr::Ascii("wtare"), + ], + values: &[ + &["sophisticated"], + &["softened"], + &["software"], + &["software"], + &["software"], + &["software"], + ], + range: 4..=9, }; static WORD_SOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14351,12 +28208,21 @@ static WORD_SOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], ], - values: &[&["some"], &["somethin"], &["something"], &["somethings"]], range: 1..=7, }; @@ -14367,6 +28233,7 @@ static WORD_SOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -14377,6 +28244,7 @@ pub static WORD_SOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("alism"), dictgen::InsensitiveStr::Ascii("artes"), dictgen::InsensitiveStr::Ascii("eities"), + dictgen::InsensitiveStr::Ascii("ekts"), dictgen::InsensitiveStr::Ascii("ialicing"), dictgen::InsensitiveStr::Ascii("ialim"), dictgen::InsensitiveStr::Ascii("ialini"), @@ -14423,6 +28291,7 @@ pub static WORD_SOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ttish"), ], values: &[ + &["social"], &["socialism"], &["socialist"], &["socialists"], @@ -14433,6 +28302,7 @@ pub static WORD_SOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["socialism"], &["socrates"], &["societies"], + &["sockets"], &["socializing"], &["socialism"], &["socializing"], @@ -14478,7 +28348,7 @@ pub static WORD_SOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["scoreboard"], &["scottish"], ], - range: 4..=10, + range: 3..=10, }; static WORD_SOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14495,6 +28365,17 @@ pub static WORD_SOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -14505,10 +28386,19 @@ pub static WORD_SN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -14526,13 +28416,17 @@ pub static WORD_SN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), ], @@ -14540,11 +28434,20 @@ pub static WORD_SN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["sandler"], &["sandstorm"], &["sandwiches"], + &["snapped"], + &["snapshot"], + &["snapshot"], + &["snapping"], + &["snapping"], + &["snapshot"], + &["snapshots"], &["sneaks"], &["sneeze"], &["sentries"], &["singles"], &["snippet"], + &["snippets"], + &["snippet"], &["snippet"], &["snippets"], &["snippets"], @@ -14561,17 +28464,21 @@ pub static WORD_SN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["snowballing"], &["snowflake"], &["snowflake"], + &["snapshot"], + &["snapshots"], &["snuggle"], &["snowballs"], &["snowden"], + &["sync"], &["syncing"], &["syndrome"], &["synergy"], &["synopsis"], + &["syntax"], &["synthesis"], &["synthetic"], ], - range: 3..=10, + range: 2..=10, }; static WORD_SM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14583,6 +28490,11 @@ pub static WORD_SM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("aples"), dictgen::InsensitiveStr::Ascii("arpthone"), dictgen::InsensitiveStr::Ascii("artare"), @@ -14592,11 +28504,27 @@ pub static WORD_SM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("aurai"), dictgen::InsensitiveStr::Ascii("ealting"), dictgen::InsensitiveStr::Ascii("eesters"), + 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"], &["samples"], &["smartphones"], &["smarter"], @@ -14606,7 +28534,18 @@ pub static WORD_SM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["samurai"], &["smelting"], &["semesters"], + &["something"], + &["small", "smell"], + &["smaller"], &["some"], + &["smooth"], + &["smoother"], + &["smoothing"], + &["smoothing"], + &["smooth"], + &["smoothness"], + &["move"], + &["smtp", "smtpe"], ], range: 2..=9, }; @@ -14619,6 +28558,9 @@ static WORD_SL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_SL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("aptoon"), + dictgen::InsensitiveStr::Ascii("ase"), + dictgen::InsensitiveStr::Ascii("ases"), + dictgen::InsensitiveStr::Ascii("ashs"), dictgen::InsensitiveStr::Ascii("aughted"), dictgen::InsensitiveStr::Ascii("aughterd"), dictgen::InsensitiveStr::Ascii("augterhouses"), @@ -14629,26 +28571,46 @@ pub static WORD_SL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("averly"), dictgen::InsensitiveStr::Ascii("ayign"), dictgen::InsensitiveStr::Ascii("diers"), + dictgen::InsensitiveStr::Ascii("ect"), + dictgen::InsensitiveStr::Ascii("ected"), + dictgen::InsensitiveStr::Ascii("ecting"), + dictgen::InsensitiveStr::Ascii("ection"), + dictgen::InsensitiveStr::Ascii("eect"), + dictgen::InsensitiveStr::Ascii("eeped"), + dictgen::InsensitiveStr::Ascii("eepp"), dictgen::InsensitiveStr::Ascii("efies"), dictgen::InsensitiveStr::Ascii("efishness"), + dictgen::InsensitiveStr::Ascii("icable"), dictgen::InsensitiveStr::Ascii("ienced"), + dictgen::InsensitiveStr::Ascii("ient"), dictgen::InsensitiveStr::Ascii("iently"), dictgen::InsensitiveStr::Ascii("ighlty"), dictgen::InsensitiveStr::Ascii("ighly"), + dictgen::InsensitiveStr::Ascii("ightl"), dictgen::InsensitiveStr::Ascii("ighty"), + dictgen::InsensitiveStr::Ascii("ignt"), + dictgen::InsensitiveStr::Ascii("igntly"), + dictgen::InsensitiveStr::Ascii("igth"), dictgen::InsensitiveStr::Ascii("igthly"), + dictgen::InsensitiveStr::Ascii("igtly"), + dictgen::InsensitiveStr::Ascii("iped"), dictgen::InsensitiveStr::Ascii("ipperies"), dictgen::InsensitiveStr::Ascii("ipperly"), dictgen::InsensitiveStr::Ascii("ippes"), dictgen::InsensitiveStr::Ascii("ippey"), + dictgen::InsensitiveStr::Ascii("iseshow"), dictgen::InsensitiveStr::Ascii("oughtering"), dictgen::InsensitiveStr::Ascii("owy"), dictgen::InsensitiveStr::Ascii("uaghter"), dictgen::InsensitiveStr::Ascii("uaghtered"), dictgen::InsensitiveStr::Ascii("uaghtering"), + dictgen::InsensitiveStr::Ascii("uggify"), ], values: &[ &["splatoon"], + &["slash"], + &["slashes"], + &["slashes"], &["slaughtered"], &["slaughtered"], &["slaughterhouses"], @@ -14659,92 +28621,293 @@ pub static WORD_SL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["slavery"], &["slaying"], &["sliders"], + &["select"], + &["selected"], + &["selecting"], + &["selection"], + &["select"], + &["slept"], + &["sleep"], &["selfies"], &["selfishness"], + &["sliceable"], &["silenced"], + &["silent"], &["silently"], &["slightly"], &["slightly"], &["slightly"], &["slightly"], + &["slight"], + &["slightly"], + &["slight"], + &["slightly"], + &["slightly"], + &["slipped"], &["slippers"], &["slippery"], &["slippers"], &["slippery"], + &["slideshow"], &["slaughtering"], &["slowly"], &["slaughter"], &["slaughtered"], &["slaughtering"], + &["slugify"], ], range: 3..=12, }; static WORD_SK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SK_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SK_CHILDREN), value: None, }; -pub static WORD_SK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + Some(&WORD_SKP_NODE), + None, + Some(&WORD_SKR_NODE), + None, + Some(&WORD_SKT_NODE), + None, + 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("andinavian"), - dictgen::InsensitiveStr::Ascii("atebaord"), - dictgen::InsensitiveStr::Ascii("atebaording"), - dictgen::InsensitiveStr::Ascii("atebaords"), - dictgen::InsensitiveStr::Ascii("ateboad"), - dictgen::InsensitiveStr::Ascii("ateboader"), - dictgen::InsensitiveStr::Ascii("ateboaring"), - dictgen::InsensitiveStr::Ascii("ateborad"), - dictgen::InsensitiveStr::Ascii("ateborading"), - dictgen::InsensitiveStr::Ascii("atebored"), - dictgen::InsensitiveStr::Ascii("atebrand"), - dictgen::InsensitiveStr::Ascii("ateing"), - dictgen::InsensitiveStr::Ascii("ecthes"), - dictgen::InsensitiveStr::Ascii("ecthy"), - dictgen::InsensitiveStr::Ascii("elatel"), - dictgen::InsensitiveStr::Ascii("eletaal"), - dictgen::InsensitiveStr::Ascii("eletl"), - dictgen::InsensitiveStr::Ascii("eletones"), - dictgen::InsensitiveStr::Ascii("eletos"), - dictgen::InsensitiveStr::Ascii("epitcal"), - dictgen::InsensitiveStr::Ascii("eptecism"), - dictgen::InsensitiveStr::Ascii("epticals"), - dictgen::InsensitiveStr::Ascii("epticim"), - dictgen::InsensitiveStr::Ascii("epticisim"), - dictgen::InsensitiveStr::Ascii("epticles"), - dictgen::InsensitiveStr::Ascii("epticons"), - dictgen::InsensitiveStr::Ascii("eptis"), - dictgen::InsensitiveStr::Ascii("eptisicm"), - dictgen::InsensitiveStr::Ascii("eptisism"), - dictgen::InsensitiveStr::Ascii("etchey"), - dictgen::InsensitiveStr::Ascii("etchs"), - dictgen::InsensitiveStr::Ascii("etchysex"), - dictgen::InsensitiveStr::Ascii("etpic"), - dictgen::InsensitiveStr::Ascii("etpical"), - dictgen::InsensitiveStr::Ascii("etpicism"), - dictgen::InsensitiveStr::Ascii("etpics"), - dictgen::InsensitiveStr::Ascii("illhosts"), - dictgen::InsensitiveStr::Ascii("illshits"), - dictgen::InsensitiveStr::Ascii("illshoot"), - dictgen::InsensitiveStr::Ascii("illshoots"), - dictgen::InsensitiveStr::Ascii("illshosts"), - dictgen::InsensitiveStr::Ascii("illslots"), - dictgen::InsensitiveStr::Ascii("illsofts"), - dictgen::InsensitiveStr::Ascii("illsshot"), - dictgen::InsensitiveStr::Ascii("illsto"), - dictgen::InsensitiveStr::Ascii("imrish"), - dictgen::InsensitiveStr::Ascii("irmiches"), - dictgen::InsensitiveStr::Ascii("petic"), - dictgen::InsensitiveStr::Ascii("peticism"), - dictgen::InsensitiveStr::Ascii("petics"), - dictgen::InsensitiveStr::Ascii("rawberries"), - dictgen::InsensitiveStr::Ascii("rimish"), - dictgen::InsensitiveStr::Ascii("teches"), - dictgen::InsensitiveStr::Ascii("techy"), - dictgen::InsensitiveStr::Ascii("wyard"), - dictgen::InsensitiveStr::Ascii("ywalkr"), + 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("yard")], + values: &[&["skyward"]], + range: 4..=4, +}; + +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_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("ped"), + dictgen::InsensitiveStr::Ascii("ping"), + dictgen::InsensitiveStr::Ascii("pp"), + dictgen::InsensitiveStr::Ascii("ppd"), + dictgen::InsensitiveStr::Ascii("pt"), + dictgen::InsensitiveStr::Ascii("rmiches"), ], values: &[ + &["skilful", "skilful"], + &["skillful", "skillful", "skillfully", "skillfully"], + &["skillfulness", "skillfulness"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skillshots"], + &["skirmish"], + &["skipped"], + &["skipped", "skyped"], + &["skipping"], + &["skip", "skipped"], + &["skipped"], + &["skip", "skype", "skipped"], + &["skirmish"], + ], + 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("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"], + &["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"], @@ -14757,52 +28920,8 @@ pub static WORD_SK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["skateboard"], &["skateboard"], &["skating"], - &["sketches"], - &["sketchy"], - &["skeletal"], - &["skeletal"], - &["skeletal"], - &["skeletons"], - &["skeletons"], - &["skeptical"], - &["skepticism"], - &["skeptics"], - &["skepticism"], - &["skepticism"], - &["skeptics"], - &["skeptics"], - &["skeptics"], - &["skepticism"], - &["skepticism"], - &["sketchy"], - &["sketches"], - &["sketches"], - &["skeptic"], - &["skeptical"], - &["skepticism"], - &["skeptics"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skillshots"], - &["skirmish"], - &["skirmish"], - &["skeptic"], - &["skepticism"], - &["skeptics"], - &["strawberries"], - &["skirmish"], - &["sketches"], - &["sketchy"], - &["skyward"], - &["skywalker"], ], - range: 5..=11, + range: 3..=10, }; static WORD_SI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14816,7 +28935,7 @@ static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SIC_NODE), Some(&WORD_SID_NODE), Some(&WORD_SIE_NODE), - None, + Some(&WORD_SIF_NODE), Some(&WORD_SIG_NODE), Some(&WORD_SIH_NODE), None, @@ -14825,15 +28944,15 @@ static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SIL_NODE), Some(&WORD_SIM_NODE), Some(&WORD_SIN_NODE), + Some(&WORD_SIO_NODE), + Some(&WORD_SIP_NODE), None, - None, - None, - None, + Some(&WORD_SIR_NODE), Some(&WORD_SIS_NODE), Some(&WORD_SIT_NODE), Some(&WORD_SIU_NODE), - None, - None, + Some(&WORD_SIV_NODE), + Some(&WORD_SIW_NODE), Some(&WORD_SIX_NODE), None, Some(&WORD_SIZ_NODE), @@ -14845,9 +28964,12 @@ static WORD_SIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ebale")], - values: &[&["sizeable"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ebale"), + dictgen::InsensitiveStr::Ascii("re"), + ], + values: &[&["sizeable"], &["size"]], + range: 2..=5, }; static WORD_SIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14857,19 +28979,48 @@ static WORD_SIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SIX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[dictgen::InsensitiveStr::Ascii("tin")], - values: &[&["sistine"]], + 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("ible")], + values: &[&["visible"]], + range: 4..=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("tational")], - values: &[&["situational"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("tational"), + dictgen::InsensitiveStr::Ascii("te"), + ], + values: &[&["situational"], &["suite"]], + range: 2..=8, }; static WORD_SIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14879,9 +29030,15 @@ static WORD_SIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ll"), dictgen::InsensitiveStr::Ascii("muli"), dictgen::InsensitiveStr::Ascii("rring"), dictgen::InsensitiveStr::Ascii("uacional"), @@ -14889,20 +29046,52 @@ pub static WORD_SIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["stimuli"], &["stirring"], &["situational"], &["situational"], + &["situations", "situational"], + &["situational", "situationally"], + &["situational"], + &["situation"], + &["situations"], + &["situation"], + &["situations"], + &["stubbornness"], + &["studio"], + &["studios"], + &["situation"], + &["situations"], + &["situation"], + &["situations"], + &["situation"], &["situations"], - &["situational"], - &["situational"], ], - range: 4..=9, + range: 2..=10, }; static WORD_SIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -14911,68 +29100,363 @@ static WORD_SIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tematically")], - values: &[&["systematically"]], - range: 11..=11, + keys: &[ + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("nce"), + 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"), + ], + values: &[ + &["size", "sisal"], + &["since"], + &["system"], + &["systematically"], + &["systematics"], + &["systematies"], + &["systematising"], + &["systematizing"], + &["systematy"], + &["systemed"], + &["systemic"], + &["systemically"], + &["systemics"], + &["systemic", "stemming"], + &["systemist"], + &["systemists"], + &["systemize"], + &["systemized"], + &["systemizes"], + &["systemizing"], + &["systems"], + ], + range: 1..=11, }; -static WORD_SIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SIN_CHILDREN), +static WORD_SIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SIR_CHILDREN), value: None, }; -pub static WORD_SIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_SIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("agpore"), - dictgen::InsensitiveStr::Ascii("cereley"), - dictgen::InsensitiveStr::Ascii("cerelly"), - dictgen::InsensitiveStr::Ascii("cerley"), - dictgen::InsensitiveStr::Ascii("gals"), - dictgen::InsensitiveStr::Ascii("gature"), - dictgen::InsensitiveStr::Ascii("gatures"), - dictgen::InsensitiveStr::Ascii("gelplayer"), - dictgen::InsensitiveStr::Ascii("gels"), - dictgen::InsensitiveStr::Ascii("gificantly"), - dictgen::InsensitiveStr::Ascii("gify"), - dictgen::InsensitiveStr::Ascii("glepalyer"), - dictgen::InsensitiveStr::Ascii("glers"), - dictgen::InsensitiveStr::Ascii("gluar"), - dictgen::InsensitiveStr::Ascii("gluarity"), - dictgen::InsensitiveStr::Ascii("gpaore"), - dictgen::InsensitiveStr::Ascii("gsog"), - dictgen::InsensitiveStr::Ascii("gualrity"), - dictgen::InsensitiveStr::Ascii("gulair"), - dictgen::InsensitiveStr::Ascii("gulaire"), - dictgen::InsensitiveStr::Ascii("gulairty"), - dictgen::InsensitiveStr::Ascii("gularily"), - dictgen::InsensitiveStr::Ascii("gulariy"), - dictgen::InsensitiveStr::Ascii("gularty"), - dictgen::InsensitiveStr::Ascii("gulary"), - dictgen::InsensitiveStr::Ascii("gulator"), - dictgen::InsensitiveStr::Ascii("istre"), - dictgen::InsensitiveStr::Ascii("lgeplayer"), - dictgen::InsensitiveStr::Ascii("se"), - dictgen::InsensitiveStr::Ascii("siter"), + 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"), ], values: &[ - &["singapore"], - &["sincerely"], - &["sincerely"], - &["sincerely"], + &["circle"], + &["circles"], + &["circular"], + &["direct"], + &["directed"], + &["directing"], + &["direction"], + &["directional"], + &["directionalities"], + &["directionality"], + &["directionals"], + &["directionless"], + &["directions"], + &["directive"], + &["directives"], + &["directly"], + &["directness"], + &["director"], + &["directories"], + &["directors"], + &["directory"], + &["directs"], + ], + 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, + None, + None, + 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_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("stre")], + values: &[&["sinister"]], + range: 4..=4, +}; + +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("lar"), + 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("ulaties"), + dictgen::InsensitiveStr::Ascii("ulator"), + ], + values: &[ + &["signal", "single"], + &["signaled"], &["signals"], &["signature"], &["signatures"], - &["singleplayer"], - &["singles"], - &["significantly"], - &["signify"], - &["singleplayer"], - &["singles"], + &["single", "signal"], &["singular"], &["singularity"], + &["singularly"], + &["singled", "signaled"], + &["singles", "signals"], + &["singleplayer"], + &["singles"], + &["singleton"], + &["significand", "significant"], + &["significantly"], + &["signify"], + &["singular"], + &["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"], @@ -14980,13 +29464,45 @@ pub static WORD_SIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["singularity"], &["singularity"], &["singularity"], + &["singularities"], &["singular"], - &["sinister"], - &["singleplayer"], - &["sines"], - &["sinister"], ], - range: 2..=10, + range: 2..=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("gpore"), + dictgen::InsensitiveStr::Ascii("ture"), + ], + values: &[&["singapore"], &["signature"]], + range: 4..=5, }; static WORD_SIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15001,7 +29517,7 @@ static WORD_SIM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_SIME_NODE), None, - None, + Some(&WORD_SIMG_NODE), None, Some(&WORD_SIMI_NODE), None, @@ -15036,6 +29552,18 @@ pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("altor"), dictgen::InsensitiveStr::Ascii("lacion"), dictgen::InsensitiveStr::Ascii("laiton"), + 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"), @@ -15063,6 +29591,7 @@ pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ltanously"), dictgen::InsensitiveStr::Ascii("lteanously"), dictgen::InsensitiveStr::Ascii("lteneous"), + dictgen::InsensitiveStr::Ascii("taneously"), ], values: &[ &["simulated"], @@ -15073,6 +29602,18 @@ pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["simulations"], &["simultaneous"], &["simultaneously"], + &["simultaneous"], + &["simultaneously"], + &["simultaneity"], + &["simultaneous"], + &["simultaneously"], + &["simultaneous"], + &["simultaneously"], + &["simultaneous"], + &["simultaneously"], + &["simulation"], + &["simultaneous"], + &["simultaneously"], &["simulate"], &["simulate"], &["simulation"], @@ -15098,8 +29639,9 @@ pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["simultaneously"], &["simultaneously"], &["simultaneous"], + &["simultaneously"], ], - range: 4..=10, + range: 4..=12, }; static WORD_SIMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15122,15 +29664,20 @@ pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("athizers"), dictgen::InsensitiveStr::Ascii("elst"), + 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("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("lificacion"), dictgen::InsensitiveStr::Ascii("lificaiton"), dictgen::InsensitiveStr::Ascii("lificating"), @@ -15139,6 +29686,9 @@ pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -15149,11 +29699,14 @@ pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("lyfied"), dictgen::InsensitiveStr::Ascii("lyifing"), dictgen::InsensitiveStr::Ascii("osn"), + dictgen::InsensitiveStr::Ascii("y"), ], values: &[ &["sympathizers"], &["simplest"], + &["simplified"], &["simplifying"], + &["simply"], &["simplest"], &["simplest"], &["simply"], @@ -15161,7 +29714,10 @@ pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["simplicity"], &["simplistic"], &["simplicity"], + &["simplicity"], &["simpler"], + &["implies", "simplifies"], + &["simplest"], &["simplification"], &["simplification"], &["simplification"], @@ -15170,6 +29726,9 @@ pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["simplify"], &["simplified"], &["simplifying"], + &["simplifies"], + &["simplification"], + &["simplifications"], &["simplistic"], &["simplistic"], &["simplicity"], @@ -15180,8 +29739,9 @@ pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["simplified"], &["simplifying"], &["simpson"], + &["simply"], ], - range: 3..=10, + range: 1..=11, }; static WORD_SIMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15190,9 +29750,19 @@ static WORD_SIMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SIMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ilar")], - values: &[&["similar"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("etric"), + dictgen::InsensitiveStr::Ascii("etrical"), + dictgen::InsensitiveStr::Ascii("etry"), + dictgen::InsensitiveStr::Ascii("ilar"), + ], + values: &[ + &["symmetric"], + &["symmetrical"], + &["symmetry"], + &["similar"], + ], + range: 4..=7, }; static WORD_SIML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15202,10 +29772,16 @@ static WORD_SIML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("iiar"), dictgen::InsensitiveStr::Ascii("uate"), dictgen::InsensitiveStr::Ascii("uated"), @@ -15214,12 +29790,19 @@ pub static WORD_SIML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["similar"], &["simulate"], &["simulated"], @@ -15228,8 +29811,9 @@ pub static WORD_SIML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["simulator"], &["simultaneous"], &["simultaneously"], + &["simply", "simile", "smiley"], ], - range: 3..=10, + range: 1..=10, }; static WORD_SIMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15240,6 +29824,8 @@ static WORD_SIMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("alir"), + dictgen::InsensitiveStr::Ascii("alr"), + dictgen::InsensitiveStr::Ascii("ar"), dictgen::InsensitiveStr::Ascii("ilar"), dictgen::InsensitiveStr::Ascii("lair"), dictgen::InsensitiveStr::Ascii("lairty"), @@ -15251,6 +29837,8 @@ pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -15258,12 +29846,16 @@ pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ltaneous"), dictgen::InsensitiveStr::Ascii("ltaneously"), + dictgen::InsensitiveStr::Ascii("ly"), ], values: &[ + &["similar"], + &["similar"], &["similar"], &["similar"], &["similar"], @@ -15278,17 +29870,32 @@ pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["similarly"], &["similar"], &["similar"], + &["similar"], + &["similar"], &["similarities"], &["similarity"], &["similarly"], &["similarities"], &["similarity"], + &["similarity"], &["similar"], &["similarities"], &["simultaneous"], &["simultaneously"], + &["simile", "smiley", "simply", "similarly"], ], - range: 3..=10, + 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 { @@ -15300,9 +29907,10 @@ pub static WORD_SIME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ltaneous"), dictgen::InsensitiveStr::Ascii("ltaneously"), + dictgen::InsensitiveStr::Ascii("ple"), ], - values: &[&["simultaneous"], &["simultaneously"]], - range: 8..=10, + values: &[&["simultaneous"], &["simultaneously"], &["simple"]], + range: 3..=10, }; static WORD_SIMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15328,10 +29936,12 @@ pub static WORD_SIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("bings"), dictgen::InsensitiveStr::Ascii("ders"), + dictgen::InsensitiveStr::Ascii("entely"), dictgen::InsensitiveStr::Ascii("enty"), dictgen::InsensitiveStr::Ascii("houete"), dictgen::InsensitiveStr::Ascii("icoln"), dictgen::InsensitiveStr::Ascii("icoon"), + dictgen::InsensitiveStr::Ascii("iently"), dictgen::InsensitiveStr::Ascii("imiar"), dictgen::InsensitiveStr::Ascii("ohuette"), dictgen::InsensitiveStr::Ascii("ouhette"), @@ -15340,9 +29950,11 @@ pub static WORD_SIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["siblings"], &["sliders"], &["silently"], + &["silently"], &["silhouette"], &["silicon"], &["silicon"], + &["silently", "saliently"], &["similar"], &["silhouette"], &["silhouette"], @@ -15368,17 +29980,39 @@ static WORD_SIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("al"), + dictgen::InsensitiveStr::Ascii("aled"), + dictgen::InsensitiveStr::Ascii("als"), dictgen::InsensitiveStr::Ascii("anture"), dictgen::InsensitiveStr::Ascii("antures"), + dictgen::InsensitiveStr::Ascii("en"), dictgen::InsensitiveStr::Ascii("htstine"), + dictgen::InsensitiveStr::Ascii("ificance"), dictgen::InsensitiveStr::Ascii("inificant"), + dictgen::InsensitiveStr::Ascii("inificantly"), + dictgen::InsensitiveStr::Ascii("inify"), + dictgen::InsensitiveStr::Ascii("it"), + dictgen::InsensitiveStr::Ascii("its"), + dictgen::InsensitiveStr::Ascii("le"), + dictgen::InsensitiveStr::Ascii("les"), + dictgen::InsensitiveStr::Ascii("leton"), + dictgen::InsensitiveStr::Ascii("nabl"), + dictgen::InsensitiveStr::Ascii("nales"), + dictgen::InsensitiveStr::Ascii("nall"), dictgen::InsensitiveStr::Ascii("napore"), dictgen::InsensitiveStr::Ascii("natue"), + dictgen::InsensitiveStr::Ascii("natur"), dictgen::InsensitiveStr::Ascii("nficant"), + dictgen::InsensitiveStr::Ascii("nficantly"), dictgen::InsensitiveStr::Ascii("nficiant"), dictgen::InsensitiveStr::Ascii("nfies"), dictgen::InsensitiveStr::Ascii("nfiy"), + dictgen::InsensitiveStr::Ascii("nguature"), + dictgen::InsensitiveStr::Ascii("nifanct"), + dictgen::InsensitiveStr::Ascii("nifant"), dictgen::InsensitiveStr::Ascii("nifantly"), + dictgen::InsensitiveStr::Ascii("nifcant"), + dictgen::InsensitiveStr::Ascii("nifcantly"), dictgen::InsensitiveStr::Ascii("nifiant"), dictgen::InsensitiveStr::Ascii("nificane"), dictgen::InsensitiveStr::Ascii("nificanlty"), @@ -15398,23 +30032,48 @@ pub static WORD_SIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nitories"), dictgen::InsensitiveStr::Ascii("nitory"), dictgen::InsensitiveStr::Ascii("nitures"), + dictgen::InsensitiveStr::Ascii("nle"), dictgen::InsensitiveStr::Ascii("nleplayer"), dictgen::InsensitiveStr::Ascii("nles"), + dictgen::InsensitiveStr::Ascii("nol"), + dictgen::InsensitiveStr::Ascii("nul"), dictgen::InsensitiveStr::Ascii("nular"), dictgen::InsensitiveStr::Ascii("nularity"), dictgen::InsensitiveStr::Ascii("thstone"), ], values: &[ + &["signal", "sigil"], + &["signaled"], + &["signals", "sigils"], &["signature"], &["signatures"], + &["sign"], &["sightstone"], + &["significance"], &["significant"], + &["significantly"], + &["signify"], + &["digit"], + &["digits"], + &["single", "sigil"], + &["singles", "sigils"], + &["singleton"], + &["signable", "signal"], + &["signals"], + &["signal"], &["singapore"], - &["signatures"], + &["signatures", "signature"], + &["signature"], &["significant"], + &["significantly"], &["significant"], &["signifies"], &["signify"], + &["signature"], + &["significant"], + &["significant"], + &["significantly"], + &["significant"], &["significantly"], &["significant"], &["significance"], @@ -15435,22 +30094,50 @@ pub static WORD_SIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["signatories"], &["signatory"], &["signatures"], + &["single", "signal"], &["singleplayer"], - &["singles"], + &["singles", "signals"], + &["signal"], + &["signal"], &["singular"], &["singularity"], &["sightstone"], ], - range: 4..=10, + range: 2..=11, +}; + +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: None, + value: Some(&["size", "sigh"]), }; pub static WORD_SIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("z"), dictgen::InsensitiveStr::Ascii("zable"), dictgen::InsensitiveStr::Ascii("ze"), dictgen::InsensitiveStr::Ascii("zed"), @@ -15459,14 +30146,16 @@ pub static WORD_SIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("zures"), ], values: &[ + &["size", "sighs"], + &["size", "seize"], &["sizable"], - &["seize"], - &["seized"], - &["seizing"], + &["seize", "size"], + &["seized", "sized"], + &["seizing", "sizing"], &["seizure"], &["seizures"], ], - range: 2..=5, + range: 1..=5, }; static WORD_SID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15476,6 +30165,7 @@ static WORD_SID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -15484,8 +30174,10 @@ pub static WORD_SID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("elinked"), dictgen::InsensitiveStr::Ascii("eral"), dictgen::InsensitiveStr::Ascii("leine"), + dictgen::InsensitiveStr::Ascii("uction"), ], values: &[ + &["side"], &["sideboard"], &["sideboard"], &["sideline"], @@ -15494,8 +30186,9 @@ pub static WORD_SID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sideline"], &["sidereal"], &["sideline"], + &["seduction"], ], - range: 4..=7, + range: 2..=7, }; static WORD_SIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15504,9 +30197,13 @@ static WORD_SIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ne")], - values: &[&["since"]], - range: 2..=2, + keys: &[ + dictgen::InsensitiveStr::Ascii("inct"), + dictgen::InsensitiveStr::Ascii("inctly"), + dictgen::InsensitiveStr::Ascii("ne"), + ], + values: &[&["succinct"], &["succinctly"], &["since"]], + range: 2..=6, }; static WORD_SIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15515,9 +30212,12 @@ static WORD_SIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lins")], - values: &[&["siblings"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("iling"), + dictgen::InsensitiveStr::Ascii("lins"), + ], + values: &[&["sibling"], &["siblings"]], + range: 4..=5, }; static WORD_SH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15527,7 +30227,7 @@ static WORD_SH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_SHA_NODE), - None, + Some(&WORD_SHB_NODE), Some(&WORD_SHC_NODE), None, Some(&WORD_SHE_NODE), @@ -15550,19 +30250,45 @@ static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_SHW_NODE), None, - 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")], - values: &[&["shawshank"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("ashank"), + dictgen::InsensitiveStr::Ascii("o"), + ], + values: &[&["shawshank"], &["show"]], + range: 1..=6, }; static WORD_SHU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15571,9 +30297,25 @@ static WORD_SHU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SHU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("oldnt")], - values: &[&["shouldnt"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ld"), + 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: &[ + &["should"], + &["shouldnt"], + &["sure"], + &["surely"], + &["shutdown"], + &["shutting"], + &["shutdown"], + ], + range: 2..=6, }; static WORD_SHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15582,9 +30324,33 @@ static WORD_SHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iless")], - values: &[&["shitless"]], - range: 5..=5, + 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"), + dictgen::InsensitiveStr::Ascii("tp"), + ], + values: &[ + &["shitless"], + &["stop", "shop"], + &["stopped", "shopped"], + &["stops", "shops"], + &["stopping", "shopping"], + &["stop", "shop"], + &["stopped", "shopped"], + &["stops", "shops"], + &["stopping", "shopping"], + &["stops", "shops"], + &["https"], + ], + range: 2..=6, }; static WORD_SHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15597,6 +30363,8 @@ pub static WORD_SHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -15605,11 +30373,13 @@ pub static WORD_SHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["shrapnel"], &["shriek"], &["sherlock"], + &["threshold"], + &["shrinks"], &["shirley"], &["shrunk"], &["shrapnel"], ], - range: 3..=5, + range: 3..=6, }; static WORD_SHP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15619,11 +30389,24 @@ static WORD_SHP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ere"), dictgen::InsensitiveStr::Ascii("eres"), dictgen::InsensitiveStr::Ascii("erical"), + dictgen::InsensitiveStr::Ascii("ped"), ], - values: &[&["spheres"], &["spherical"]], - range: 4..=6, + values: &[ + &["shape"], + &["shapes"], + &["shapes"], + &["sphere"], + &["spheres"], + &["spherical"], + &["shipped"], + ], + range: 2..=6, }; static WORD_SHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15633,50 +30416,112 @@ static WORD_SHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("pkeeepers"), + 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("rtend"), dictgen::InsensitiveStr::Ascii("rtenend"), dictgen::InsensitiveStr::Ascii("rtenning"), dictgen::InsensitiveStr::Ascii("rtenting"), + dictgen::InsensitiveStr::Ascii("rtern"), dictgen::InsensitiveStr::Ascii("rtining"), + dictgen::InsensitiveStr::Ascii("rtkut"), + dictgen::InsensitiveStr::Ascii("rtkuts"), + dictgen::InsensitiveStr::Ascii("tcut"), + dictgen::InsensitiveStr::Ascii("tdown"), dictgen::InsensitiveStr::Ascii("tuout"), + dictgen::InsensitiveStr::Ascii("ucl"), + dictgen::InsensitiveStr::Ascii("ud"), 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("uldbe"), dictgen::InsensitiveStr::Ascii("uldes"), dictgen::InsensitiveStr::Ascii("uldnot"), dictgen::InsensitiveStr::Ascii("uldt"), + dictgen::InsensitiveStr::Ascii("ule"), 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: &[ + &["software"], + &["should"], + &["showing"], + &["should", "hold", "sold"], + &["shoulder"], + &["should"], &["shopkeepers"], + &["shortcuts"], &["shortly"], + &["shortcut"], + &["shortcuts"], + &["shortcoming"], + &["shortcomings"], &["shortened"], &["shortened"], &["shortening"], &["shortening"], + &["shorten"], &["shortening"], + &["shortcut"], + &["shortcuts"], + &["shortcut"], + &["shutdown"], &["shoutout"], &["should"], + &["should"], + &["should"], + &["should"], + &["should"], &["shoulders"], &["should"], &["shouldnt"], + &["shouldn"], + &["should"], + &["should"], &["shoulders"], &["shouldnt"], &["shouldnt"], + &["should"], &["shouldnt"], + &["should"], + &["should"], + &["should"], &["shoutout"], + &["show"], + &["shows"], &["snowboarding"], &["showered"], &["showered"], + &["chauffeur", "shower"], + &["chauvinism"], ], - range: 3..=9, + range: 2..=10, }; static WORD_SHN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15713,7 +30558,9 @@ static WORD_SHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -15731,7 +30578,9 @@ pub static WORD_SHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ttown"), ], values: &[ + &["chicane"], &["shielded"], + &["shift"], &["shifting"], &["shifter"], &["shielded"], @@ -15748,7 +30597,7 @@ pub static WORD_SHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["shitton"], &["shitton"], ], - range: 3..=7, + range: 1..=7, }; static WORD_SHF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15773,14 +30622,27 @@ static WORD_SHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("akspeare"), + dictgen::InsensitiveStr::Ascii("at"), + dictgen::InsensitiveStr::Ascii("ck"), + dictgen::InsensitiveStr::Ascii("cked"), + dictgen::InsensitiveStr::Ascii("cker"), + dictgen::InsensitiveStr::Ascii("cking"), + dictgen::InsensitiveStr::Ascii("cks"), + dictgen::InsensitiveStr::Ascii("dule"), + dictgen::InsensitiveStr::Ascii("duled"), + dictgen::InsensitiveStr::Ascii("dules"), + dictgen::InsensitiveStr::Ascii("duling"), dictgen::InsensitiveStr::Ascii("elpe"), dictgen::InsensitiveStr::Ascii("epel"), + dictgen::InsensitiveStr::Ascii("epherd"), + dictgen::InsensitiveStr::Ascii("epherds"), dictgen::InsensitiveStr::Ascii("ild"), dictgen::InsensitiveStr::Ascii("ilded"), dictgen::InsensitiveStr::Ascii("ilding"), dictgen::InsensitiveStr::Ascii("lterd"), dictgen::InsensitiveStr::Ascii("lvers"), dictgen::InsensitiveStr::Ascii("lveys"), + dictgen::InsensitiveStr::Ascii("me"), dictgen::InsensitiveStr::Ascii("nadigans"), dictgen::InsensitiveStr::Ascii("nanagans"), dictgen::InsensitiveStr::Ascii("nanagins"), @@ -15796,9 +30658,13 @@ pub static WORD_SHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nenigans"), dictgen::InsensitiveStr::Ascii("ninigans"), dictgen::InsensitiveStr::Ascii("nnaigans"), + dictgen::InsensitiveStr::Ascii("pe"), dictgen::InsensitiveStr::Ascii("pharded"), dictgen::InsensitiveStr::Ascii("phed"), dictgen::InsensitiveStr::Ascii("phered"), + dictgen::InsensitiveStr::Ascii("pre"), + dictgen::InsensitiveStr::Ascii("pres"), + dictgen::InsensitiveStr::Ascii("rif"), dictgen::InsensitiveStr::Ascii("rlcok"), dictgen::InsensitiveStr::Ascii("rlok"), dictgen::InsensitiveStr::Ascii("tler"), @@ -15807,14 +30673,27 @@ pub static WORD_SHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["shakespeare"], + &["sheath", "sheet", "cheat"], + &["check", "check", "shuck"], + &["checked", "shucked"], + &["checker", "shucker"], + &["checking", "shucking"], + &["checks", "checks", "shucks"], + &["schedule"], + &["scheduled"], + &["schedules"], + &["scheduling"], &["sheeple"], &["sheeple"], + &["shepherd"], + &["shepherds"], &["shield"], &["shielded"], &["shielding"], &["sheltered"], &["shelves"], &["shelves"], + &["scheme", "shame"], &["shenanigans"], &["shenanigans"], &["shenanigans"], @@ -15830,16 +30709,20 @@ pub static WORD_SHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["shenanigans"], &["shenanigans"], &["shenanigans"], + &["shape"], &["shepherd"], &["shepherd"], &["shepherd"], + &["sphere"], + &["spheres"], + &["sheriff"], &["sherlock"], &["sherlock"], &["shelter"], &["shelters"], &["shelves"], ], - range: 3..=9, + range: 2..=9, }; static WORD_SHC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -15863,6 +30746,17 @@ pub static WORD_SHC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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::Flat(&WORD_SHA_CHILDREN), value: None, @@ -15872,6 +30766,7 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("dasloo"), dictgen::InsensitiveStr::Ascii("ddow"), + dictgen::InsensitiveStr::Ascii("dhow"), dictgen::InsensitiveStr::Ascii("doloo"), dictgen::InsensitiveStr::Ascii("keapeare"), dictgen::InsensitiveStr::Ascii("kepseare"), @@ -15886,6 +30781,10 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("melessy"), dictgen::InsensitiveStr::Ascii("men"), dictgen::InsensitiveStr::Ascii("mpionship"), + dictgen::InsensitiveStr::Ascii("ndeleer"), + dictgen::InsensitiveStr::Ascii("ndeleers"), + dictgen::InsensitiveStr::Ascii("ndow"), + dictgen::InsensitiveStr::Ascii("neal"), dictgen::InsensitiveStr::Ascii("nenigans"), dictgen::InsensitiveStr::Ascii("ngahi"), dictgen::InsensitiveStr::Ascii("nghi"), @@ -15895,18 +30794,24 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("prly"), dictgen::InsensitiveStr::Ascii("prness"), dictgen::InsensitiveStr::Ascii("rdholders"), + dictgen::InsensitiveStr::Ascii("reed"), dictgen::InsensitiveStr::Ascii("reholdes"), dictgen::InsensitiveStr::Ascii("reholds"), dictgen::InsensitiveStr::Ascii("ripe"), dictgen::InsensitiveStr::Ascii("rkening"), + dictgen::InsensitiveStr::Ascii("rloton"), dictgen::InsensitiveStr::Ascii("rpeneing"), dictgen::InsensitiveStr::Ascii("rpenning"), dictgen::InsensitiveStr::Ascii("rpenss"), dictgen::InsensitiveStr::Ascii("rpining"), dictgen::InsensitiveStr::Ascii("rplay"), dictgen::InsensitiveStr::Ascii("rpley"), + dictgen::InsensitiveStr::Ascii("rraid"), + dictgen::InsensitiveStr::Ascii("rraids"), dictgen::InsensitiveStr::Ascii("rtening"), + dictgen::InsensitiveStr::Ascii("shes"), dictgen::InsensitiveStr::Ascii("tnering"), + dictgen::InsensitiveStr::Ascii("tow"), dictgen::InsensitiveStr::Ascii("ttening"), dictgen::InsensitiveStr::Ascii("tterling"), dictgen::InsensitiveStr::Ascii("tterring"), @@ -15916,6 +30821,7 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["shadaloo"], &["shadow"], + &["shadow"], &["shadaloo"], &["shakespeare"], &["shakespeare"], @@ -15928,8 +30834,12 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["shamelessly"], &["shamelessly"], &["shamelessly"], - &["shaman"], + &["shaman", "shamans"], &["championship"], + &["chandelier"], + &["chandeliers"], + &["shadow"], + &["chenille"], &["shenanigans"], &["shanghai"], &["shanghai"], @@ -15939,18 +30849,24 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sharply"], &["sharpness"], &["shareholders"], + &["shared"], &["shareholders"], &["shareholders"], &["sharpie"], &["sharpening"], + &["charlatan"], &["sharpening"], &["sharpening"], &["sharpness"], &["sharpening"], &["sharply"], &["sharply"], + &["charade"], + &["charades"], &["sharpening"], + &["slashes"], &["shattering"], + &["château"], &["shattering"], &["shattering"], &["shattering"], @@ -15960,6 +30876,28 @@ pub static WORD_SHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 3..=9, }; +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, @@ -15970,25 +30908,25 @@ static WORD_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SEB_NODE), Some(&WORD_SEC_NODE), Some(&WORD_SED_NODE), - None, + Some(&WORD_SEE_NODE), Some(&WORD_SEF_NODE), Some(&WORD_SEG_NODE), - None, + Some(&WORD_SEH_NODE), Some(&WORD_SEI_NODE), None, - None, + Some(&WORD_SEK_NODE), Some(&WORD_SEL_NODE), Some(&WORD_SEM_NODE), Some(&WORD_SEN_NODE), - None, + Some(&WORD_SEO_NODE), Some(&WORD_SEP_NODE), - None, + Some(&WORD_SEQ_NODE), Some(&WORD_SER_NODE), Some(&WORD_SES_NODE), Some(&WORD_SET_NODE), Some(&WORD_SEU_NODE), Some(&WORD_SEV_NODE), - None, + Some(&WORD_SEW_NODE), Some(&WORD_SEX_NODE), None, Some(&WORD_SEZ_NODE), @@ -16042,6 +30980,21 @@ pub static WORD_SEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -16049,26 +31002,44 @@ static WORD_SEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("erl"), dictgen::InsensitiveStr::Ascii("erley"), dictgen::InsensitiveStr::Ascii("erly"), dictgen::InsensitiveStr::Ascii("ice"), + dictgen::InsensitiveStr::Ascii("rity"), ], values: &[ + &["several"], + &["save", "sieve"], &["seventeen"], &["seventeen"], &["several"], &["severed"], &["severed"], + &["severity"], + &["severities"], + &["severity"], + &["severities"], + &["severity", "severities"], + &["several"], &["severely"], &["severely"], &["service"], + &["severity"], ], - range: 3..=7, + range: 1..=9, }; static WORD_SEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -16077,9 +31048,13 @@ static WORD_SEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("xalized")], - values: &[&["sexualized"]], - range: 7..=7, + 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 { @@ -16089,30 +31064,68 @@ static WORD_SET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("tigns"), + dictgen::InsensitiveStr::Ascii("tigs"), + 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("tup"), ], values: &[ + &["setgid"], + &["setting"], + &["settings"], + &["section"], + &["sections"], + &["settees"], + &["setting"], + &["settings"], + &["sequential"], + &["set"], &["settlement"], &["settlement"], &["settlements"], &["settings"], &["settings"], + &["settings"], + &["settings"], + &["settings"], &["settlements"], &["settlements"], &["settlements"], &["settlements"], &["settlement"], + &["setting"], + &["setter"], + &["setters"], + &["setting"], + &["settings"], + &["setup"], ], - range: 4..=8, + range: 2..=8, }; static WORD_SES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -16122,139 +31135,932 @@ static WORD_SES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("itive"), dictgen::InsensitiveStr::Ascii("katchewan"), dictgen::InsensitiveStr::Ascii("nors"), + dictgen::InsensitiveStr::Ascii("sio"), + dictgen::InsensitiveStr::Ascii("ssion"), + dictgen::InsensitiveStr::Ascii("ssions"), + dictgen::InsensitiveStr::Ascii("tatusbar"), + dictgen::InsensitiveStr::Ascii("tatusmsg"), ], - values: &[&["saskatchewan"], &["sensors"]], - range: 4..=9, + values: &[ + &["sensitive"], + &["saskatchewan"], + &["sensors"], + &["session"], + &["session"], + &["sessions"], + &["setstatusbar"], + &["setstatusmsg"], + ], + range: 3..=9, }; static WORD_SER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SER_CHILDREN), + 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, + None, + None, + None, + None, + 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_SER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ached"), - dictgen::InsensitiveStr::Ascii("aches"), - dictgen::InsensitiveStr::Ascii("aching"), - dictgen::InsensitiveStr::Ascii("bain"), - dictgen::InsensitiveStr::Ascii("enitary"), - dictgen::InsensitiveStr::Ascii("entiy"), - dictgen::InsensitiveStr::Ascii("gaent"), - dictgen::InsensitiveStr::Ascii("geat"), - dictgen::InsensitiveStr::Ascii("gent"), - dictgen::InsensitiveStr::Ascii("iban"), - dictgen::InsensitiveStr::Ascii("iosuly"), - dictgen::InsensitiveStr::Ascii("ioulsy"), - dictgen::InsensitiveStr::Ascii("iuosly"), - dictgen::InsensitiveStr::Ascii("ivceable"), - dictgen::InsensitiveStr::Ascii("tificates"), - dictgen::InsensitiveStr::Ascii("vans"), - dictgen::InsensitiveStr::Ascii("vantes"), - dictgen::InsensitiveStr::Ascii("veillance"), - dictgen::InsensitiveStr::Ascii("viceble"), - dictgen::InsensitiveStr::Ascii("viciable"), + dictgen::InsensitiveStr::Ascii("ans"), + dictgen::InsensitiveStr::Ascii("antes"), + dictgen::InsensitiveStr::Ascii("ce"), + dictgen::InsensitiveStr::Ascii("ced"), + dictgen::InsensitiveStr::Ascii("ces"), + 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("eral"), + dictgen::InsensitiveStr::Ascii("erite"), + dictgen::InsensitiveStr::Ascii("erites"), + dictgen::InsensitiveStr::Ascii("eritie"), + dictgen::InsensitiveStr::Ascii("erities"), + dictgen::InsensitiveStr::Ascii("erity"), + dictgen::InsensitiveStr::Ascii("iceble"), + dictgen::InsensitiveStr::Ascii("iciable"), + dictgen::InsensitiveStr::Ascii("ie"), + dictgen::InsensitiveStr::Ascii("ies"), + 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"], + &["servicing", "serving"], + &["service"], + &["serviced"], + &["services"], + &["servicing"], + &["service"], + &["serviced"], + &["services"], + &["servicing"], + &["surveillance"], + &["several"], + &["severity"], + &["severities"], + &["severity", "severities"], + &["severities"], + &["severity"], + &["serviceable"], + &["serviceable"], + &["service"], + &["services"], + &["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_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("aliazation"), + dictgen::InsensitiveStr::Ascii("ban"), + dictgen::InsensitiveStr::Ascii("ce"), + dictgen::InsensitiveStr::Ascii("ces"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("eses"), + dictgen::InsensitiveStr::Ascii("os"), + dictgen::InsensitiveStr::Ascii("osuly"), + dictgen::InsensitiveStr::Ascii("oulsy"), + dictgen::InsensitiveStr::Ascii("ouly"), + dictgen::InsensitiveStr::Ascii("uos"), + dictgen::InsensitiveStr::Ascii("uosly"), + dictgen::InsensitiveStr::Ascii("vce"), + dictgen::InsensitiveStr::Ascii("vceable"), + dictgen::InsensitiveStr::Ascii("vces"), + ], + values: &[ + &["serialization"], + &["serbian"], + &["service"], + &["services", "series"], + &["series"], + &["series"], + &["serious"], + &["seriously"], + &["seriously"], + &["seriously"], + &["serious"], + &["seriously"], + &["service"], + &["serviceable"], + &["services"], + ], + range: 1..=10, +}; + +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"), + ], + values: &[&["sergeant"], &["sergeant"], &["sergeant"]], + range: 3..=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("nitary"), + dictgen::InsensitiveStr::Ascii("ntiy"), + ], + values: &[&["serenity"], &["serenity"]], + range: 4..=6, +}; + +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("ive"), + dictgen::InsensitiveStr::Ascii("ived"), + dictgen::InsensitiveStr::Ascii("ives"), + dictgen::InsensitiveStr::Ascii("iving"), + ], + values: &[&["service"], &["serviced"], &["services"], &["servicing"]], + range: 3..=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("ches"), + dictgen::InsensitiveStr::Ascii("ching"), + dictgen::InsensitiveStr::Ascii("ilisation"), + dictgen::InsensitiveStr::Ascii("ilization"), + dictgen::InsensitiveStr::Ascii("ilized"), + dictgen::InsensitiveStr::Ascii("ilze"), + dictgen::InsensitiveStr::Ascii("ilzed"), + ], + values: &[ + &["search"], &["searched"], &["searches"], &["searching"], - &["serbian"], - &["serenity"], - &["serenity"], - &["sergeant"], - &["sergeant"], - &["sergeant"], - &["serbian"], - &["seriously"], - &["seriously"], - &["seriously"], - &["serviceable"], - &["certificates"], - &["servants"], - &["servants"], - &["surveillance"], - &["serviceable"], - &["serviceable"], + &["serialisation"], + &["serialization"], + &["serialized"], + &["serialize"], + &["serialized"], + ], + 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("euencer"), + dictgen::InsensitiveStr::Ascii("euental"), + dictgen::InsensitiveStr::Ascii("eunce"), + dictgen::InsensitiveStr::Ascii("euncer"), + dictgen::InsensitiveStr::Ascii("euntials"), + dictgen::InsensitiveStr::Ascii("ucne"), + dictgen::InsensitiveStr::Ascii("uece"), + 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("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("unces"), + ], + values: &[ + &["sequence"], + &["sequenced"], + &["sequences"], + &["sequencing"], + &["sequence"], + &["sequenced"], + &["sequences"], + &["sequencing"], + &["sequential"], + &["sequential"], + &["sequencer"], + &["sequential"], + &["sequence"], + &["sequencer"], + &["sequentials"], + &["sequence"], + &["sequence"], + &["sequences"], + &["sequence"], + &["sequence"], + &["sequence"], + &["sequences"], + &["sequential"], + &["sequentially"], + &["sequences"], + &["sequence"], + &["sequenced"], + &["sequences"], + &["sequencing"], + &["sequential"], + &["sequentially"], + &["sequences"], + &["sequential"], + &["squeeze", "sequence"], + &["sequences"], ], range: 4..=9, }; static WORD_SEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SEP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SEP_CHILDREN), value: None, }; -pub static WORD_SEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aracion"), - dictgen::InsensitiveStr::Ascii("aratedly"), - dictgen::InsensitiveStr::Ascii("aratelly"), - dictgen::InsensitiveStr::Ascii("araters"), - dictgen::InsensitiveStr::Ascii("aratisme"), - dictgen::InsensitiveStr::Ascii("aratiste"), - dictgen::InsensitiveStr::Ascii("aratley"), - dictgen::InsensitiveStr::Ascii("arato"), - dictgen::InsensitiveStr::Ascii("aratron"), - dictgen::InsensitiveStr::Ascii("arete"), - dictgen::InsensitiveStr::Ascii("aretely"), - dictgen::InsensitiveStr::Ascii("cially"), - dictgen::InsensitiveStr::Ascii("cifications"), - dictgen::InsensitiveStr::Ascii("culating"), - dictgen::InsensitiveStr::Ascii("earte"), - dictgen::InsensitiveStr::Ascii("erate"), - dictgen::InsensitiveStr::Ascii("erated"), - dictgen::InsensitiveStr::Ascii("erately"), - dictgen::InsensitiveStr::Ascii("erates"), - dictgen::InsensitiveStr::Ascii("erating"), - dictgen::InsensitiveStr::Ascii("eration"), - dictgen::InsensitiveStr::Ascii("eratism"), - dictgen::InsensitiveStr::Ascii("eratist"), - dictgen::InsensitiveStr::Ascii("eratley"), - dictgen::InsensitiveStr::Ascii("erator"), - dictgen::InsensitiveStr::Ascii("ina"), - dictgen::InsensitiveStr::Ascii("lling"), - dictgen::InsensitiveStr::Ascii("reate"), - dictgen::InsensitiveStr::Ascii("tmeber"), - dictgen::InsensitiveStr::Ascii("ulchure"), - dictgen::InsensitiveStr::Ascii("ulcre"), + dictgen::InsensitiveStr::Ascii("lchure"), + dictgen::InsensitiveStr::Ascii("lcre"), + ], + values: &[&["sepulchre", "sepulchre"], &["sepulchre", "sepulchre"]], + range: 4..=6, +}; + +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("arate"), + dictgen::InsensitiveStr::Ascii("ate"), + dictgen::InsensitiveStr::Ascii("ated"), + dictgen::InsensitiveStr::Ascii("ator"), + dictgen::InsensitiveStr::Ascii("ators"), + dictgen::InsensitiveStr::Ascii("eate"), ], values: &[ - &["separation"], - &["separately"], - &["separately"], - &["separates"], - &["separates"], - &["separates"], - &["separately"], - &["separation"], - &["separation"], &["separate"], - &["separately"], - &["specially"], - &["specification"], - &["speculating"], &["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("erate")], + values: &[&["separate"]], + range: 5..=5, +}; + +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("ling")], + values: &[&["spelling"]], + range: 4..=4, +}; + +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", "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("ator"), + dictgen::InsensitiveStr::Ascii("ators"), + 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"], - &["subpena"], - &["spelling"], + &["separators"], &["separate"], - &["september"], - &["sepulchre"], - &["sepulchre"], + &["separated"], + &["separates"], + &["separate"], + &["separated"], + &["separates"], + &["separate"], + &["separated"], + &["separates"], + &["separately"], + &["separator"], + &["separators"], + &["separator"], + &["separators"], ], - range: 3..=11, + 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("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("tae"), + dictgen::InsensitiveStr::Ascii("tate"), + ], + values: &[ + &["separate"], + &["separation"], + &["separator"], + &["separate"], + &["separately"], + &["separately"], + &["separator"], + &["separates"], + &["separates"], + &["separates"], + &["separately"], + &["separately"], + &["separation"], + &["separation"], + &["separated"], + &["separate"], + &["separated"], + &["separately"], + &["separately"], + &["separator"], + &["separates"], + &["separating"], + &["separately"], + &["separator"], + &["separates"], + &["separate"], + &["separated"], + &["separates"], + &["separating"], + &["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 { @@ -16268,7 +32074,7 @@ static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_SENC_NODE), Some(&WORD_SEND_NODE), Some(&WORD_SENE_NODE), - None, + Some(&WORD_SENF_NODE), None, None, Some(&WORD_SENI_NODE), @@ -16279,7 +32085,7 @@ static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_SENO_NODE), None, - None, + Some(&WORD_SENQ_NODE), None, Some(&WORD_SENS_NODE), Some(&WORD_SENT_NODE), @@ -16314,16 +32120,21 @@ pub static WORD_SENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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"), @@ -16331,27 +32142,37 @@ pub static WORD_SENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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"], &["sentencing"], &["sentencing"], + &["sentence"], &["sentencing"], + &["sentinel"], &["sentries"], &["sentimental"], &["sentimental"], @@ -16359,11 +32180,16 @@ pub static WORD_SENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["sentiments"], &["sentimental"], &["sentimental"], + &["sentinel"], + &["sentinels"], &["sentencing"], &["sentiments"], &["sentient"], &["sentient"], &["sentries"], + &["sensitive"], + &["sensitively", "sensitivity"], + &["sensitive"], &["sentries"], &["sentries"], ], @@ -16398,16 +32224,25 @@ pub static WORD_SENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ationilist"), dictgen::InsensitiveStr::Ascii("ationnal"), dictgen::InsensitiveStr::Ascii("ationslism"), + dictgen::InsensitiveStr::Ascii("ative"), dictgen::InsensitiveStr::Ascii("etional"), dictgen::InsensitiveStr::Ascii("etionalism"), 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("itiv"), + dictgen::InsensitiveStr::Ascii("itiveties"), dictgen::InsensitiveStr::Ascii("itivety"), 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"), @@ -16434,16 +32269,25 @@ pub static WORD_SENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["sensationalist"], &["sensational"], &["sensationalism"], + &["sensitive"], &["sensational"], &["sensationalism"], &["sensible"], &["sensibilities"], &["sensibilities"], + &["sensible"], + &["sensitive"], + &["sensitively", "sensitivity"], + &["sensitive"], + &["sensitivities"], &["sensitivity"], &["sensitivity"], &["sensitivity"], + &["sensitivities"], &["sensitivity"], - &["sensitivity"], + &["sensitivity", "sensitively"], + &["sensitive"], + &["sensitivity", "sensitively"], &["sensors"], &["sensitive"], &["censure"], @@ -16451,6 +32295,17 @@ pub static WORD_SENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -16469,20 +32324,37 @@ static WORD_SENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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, @@ -16500,9 +32372,14 @@ static WORD_SEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("etary")], - values: &[&["sedentary"]], - range: 5..=5, + 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 { @@ -16511,9 +32388,19 @@ static WORD_SENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_SENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("e")], - values: &[&["sense"]], - range: 1..=1, + 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 { @@ -16523,11 +32410,20 @@ static WORD_SENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_SENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("phore"), + dictgen::InsensitiveStr::Ascii("phores"), + dictgen::InsensitiveStr::Ascii("rio"), dictgen::InsensitiveStr::Ascii("rios"), dictgen::InsensitiveStr::Ascii("tores"), ], - values: &[&["scenarios"], &["senators"]], - range: 4..=5, + values: &[ + &["semaphore"], + &["semaphores"], + &["scenario"], + &["scenarios"], + &["senators"], + ], + range: 3..=6, }; static WORD_SEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -16537,22 +32433,80 @@ static WORD_SEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("enting"), + dictgen::InsensitiveStr::Ascii("ents"), dictgen::InsensitiveStr::Ascii("estre"), dictgen::InsensitiveStr::Ascii("estres"), + dictgen::InsensitiveStr::Ascii("gent"), + 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"], + &["cementing", "segmenting"], + &["cements", "segments"], &["semester"], &["semesters"], + &["segment"], + &["semicolon"], + &["semicolon"], + &["semiconductor"], &["semantics"], + &["semaphore"], + &["semaphores"], + &["semaphore"], + &["semaphores"], + &["semaphore"], + &["semaphores"], + &["semaphore"], &["semester"], &["semesters"], ], - range: 5..=6, + range: 3..=9, }; static WORD_SEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -16562,30 +32516,103 @@ static WORD_SEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cetion"), + 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("eced"), + dictgen::InsensitiveStr::Ascii("ecetd"), + dictgen::InsensitiveStr::Ascii("ecgt"), + dictgen::InsensitiveStr::Ascii("ecgted"), + dictgen::InsensitiveStr::Ascii("ecgting"), + dictgen::InsensitiveStr::Ascii("ecing"), + 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("eted"), + dictgen::InsensitiveStr::Ascii("etion"), + dictgen::InsensitiveStr::Ascii("etions"), dictgen::InsensitiveStr::Ascii("feshness"), dictgen::InsensitiveStr::Ascii("fiers"), dictgen::InsensitiveStr::Ascii("fishess"), + dictgen::InsensitiveStr::Ascii("fs"), dictgen::InsensitiveStr::Ascii("ifes"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("v"), ], values: &[ + &["selection"], + &["selectable"], + &["selectables"], + &["selected"], + &["selecting"], + &["selection"], + &["selections"], &["seldom"], + &["selected"], + &["selected"], + &["select"], + &["selected"], + &["selecting"], + &["selecting"], + &["selected"], + &["selected", "select"], + &["selects"], &["selective"], + &["selection", "selecting"], &["selections"], &["selectively"], &["selectively"], &["selections"], + &["selection"], + &["selection"], + &["selections"], + &["selected"], + &["selections"], + &["selector"], + &["selected", "deleted"], + &["selection", "deletion"], + &["selections", "deletions"], &["selfishness"], &["selfies"], &["selfishness"], + &["self"], &["selfies"], + &["set", "self", "sold"], + &["self"], ], - range: 4..=8, + 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 { @@ -16599,11 +32626,29 @@ pub static WORD_SEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ng"), dictgen::InsensitiveStr::Ascii("nor"), dictgen::InsensitiveStr::Ascii("nors"), + dictgen::InsensitiveStr::Ascii("res"), + ], + values: &[ + &["siege"], + &["seeing"], + &["senior"], + &["seniors"], + &["series"], ], - values: &[&["siege"], &["seeing"], &["senior"], &["seniors"]], 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, @@ -16612,8 +32657,28 @@ static WORD_SEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("egrated"), + dictgen::InsensitiveStr::Ascii("ement"), dictgen::InsensitiveStr::Ascii("ementation"), + dictgen::InsensitiveStr::Ascii("ements"), + 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("mentaion"), + dictgen::InsensitiveStr::Ascii("mente"), + dictgen::InsensitiveStr::Ascii("mentes"), + dictgen::InsensitiveStr::Ascii("metn"), + dictgen::InsensitiveStr::Ascii("metned"), + dictgen::InsensitiveStr::Ascii("metns"), dictgen::InsensitiveStr::Ascii("ragated"), dictgen::InsensitiveStr::Ascii("ragation"), dictgen::InsensitiveStr::Ascii("regacion"), @@ -16623,12 +32688,33 @@ pub static WORD_SEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("retation"), dictgen::InsensitiveStr::Ascii("rigated"), dictgen::InsensitiveStr::Ascii("rigation"), + dictgen::InsensitiveStr::Ascii("ument"), dictgen::InsensitiveStr::Ascii("uoys"), ], values: &[ &["segregated"], + &["segment"], &["segmentation"], + &["segments"], + &["segments"], &["segregation"], + &["segfault"], + &["segfaults"], + &["segmentation"], + &["segment"], + &["segmentation"], + &["segmented"], + &["segments"], + &["segment"], + &["segmented"], + &["segmented"], + &["segments"], + &["segmentation"], + &["segment"], + &["segments"], + &["segment"], + &["segmented"], + &["segments"], &["segregated"], &["segregation"], &["segregation"], @@ -16638,6 +32724,7 @@ pub static WORD_SEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["segregation"], &["segregated"], &["segregation"], + &["segment"], &["segues"], ], range: 4..=10, @@ -16657,6 +32744,37 @@ pub static WORD_SEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("lect"), + dictgen::InsensitiveStr::Ascii("mes"), + dictgen::InsensitiveStr::Ascii("mless"), + dictgen::InsensitiveStr::Ascii("mlessly"), + dictgen::InsensitiveStr::Ascii("sion"), + dictgen::InsensitiveStr::Ascii("sions"), + dictgen::InsensitiveStr::Ascii("ting"), + ], + values: &[ + &["seem"], + &["seen"], + &["select"], + &["seems"], + &["seamless"], + &["seamlessly"], + &["session"], + &["sessions"], + &["seating", "setting", "seething"], + ], + range: 2..=7, +}; + static WORD_SED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_SED_CHILDREN), value: None, @@ -16679,52 +32797,299 @@ pub static WORD_SED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_SEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SEC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SEC_CHILDREN), value: None, }; -pub static WORD_SEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ceeded"), - dictgen::InsensitiveStr::Ascii("eed"), - dictgen::InsensitiveStr::Ascii("eeded"), - dictgen::InsensitiveStr::Ascii("ertary"), - dictgen::InsensitiveStr::Ascii("ertly"), - dictgen::InsensitiveStr::Ascii("erts"), - dictgen::InsensitiveStr::Ascii("pter"), - dictgen::InsensitiveStr::Ascii("ratary"), - dictgen::InsensitiveStr::Ascii("ratery"), - dictgen::InsensitiveStr::Ascii("relty"), - dictgen::InsensitiveStr::Ascii("rest"), - dictgen::InsensitiveStr::Ascii("retas"), - dictgen::InsensitiveStr::Ascii("retery"), - dictgen::InsensitiveStr::Ascii("retley"), - dictgen::InsensitiveStr::Ascii("retos"), - dictgen::InsensitiveStr::Ascii("rety"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("ely"), + dictgen::InsensitiveStr::Ascii("irty"), + dictgen::InsensitiveStr::Ascii("ity"), + dictgen::InsensitiveStr::Ascii("nd"), + 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"), - dictgen::InsensitiveStr::Ascii("uirty"), ], values: &[ - &["seceded"], - &["succeed"], - &["succeeded"], - &["secretary"], - &["secretly"], - &["secrets"], - &["scepter"], - &["secretary"], - &["secretary"], - &["secretly"], - &["secrets"], - &["secrets"], - &["secretary"], - &["secretly"], - &["secrets"], - &["secretly"], + &["secure"], + &["securely"], + &["security"], + &["security"], + &["second"], + &["security"], + &["security"], + &["securely"], + &["secure"], + &["securely"], + &["securely"], + &["security"], + &["security"], &["security"], &["security"], ], - range: 3..=6, + range: 1..=5, +}; + +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"), + ], + values: &[ + &["section"], + &["sections"], + &["sections"], + &["sectioning"], + &["sectioned", "section"], + &["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("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"], + &["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("nadry"), + dictgen::InsensitiveStr::Ascii("ncary"), + dictgen::InsensitiveStr::Ascii("ndaray"), + dictgen::InsensitiveStr::Ascii("nday"), + dictgen::InsensitiveStr::Ascii("ndy"), + dictgen::InsensitiveStr::Ascii("nf"), + dictgen::InsensitiveStr::Ascii("nly"), + dictgen::InsensitiveStr::Ascii("nt"), + dictgen::InsensitiveStr::Ascii("ntary"), + dictgen::InsensitiveStr::Ascii("ntly"), + dictgen::InsensitiveStr::Ascii("nts"), + dictgen::InsensitiveStr::Ascii("rd"), + dictgen::InsensitiveStr::Ascii("tr"), + dictgen::InsensitiveStr::Ascii("und"), + dictgen::InsensitiveStr::Ascii("undary"), + dictgen::InsensitiveStr::Ascii("undly"), + dictgen::InsensitiveStr::Ascii("unds"), + ], + values: &[ + &["second"], + &["secondary"], + &["secondary"], + &["secondary"], + &["secondary"], + &["secondly", "secondary"], + &["second"], + &["secondly"], + &["second"], + &["secondary"], + &["secondly"], + &["seconds"], + &["second"], + &["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("on"), + dictgen::InsensitiveStr::Ascii("ons"), + dictgen::InsensitiveStr::Ascii("rity"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tons"), + ], + values: &[ + &["specific"], + &["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 { @@ -16762,6 +33127,9 @@ pub static WORD_SEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -16770,14 +33138,22 @@ pub static WORD_SEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("mlessy"), dictgen::InsensitiveStr::Ascii("ntor"), dictgen::InsensitiveStr::Ascii("ntors"), + 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("tch"), ], values: &[ &["search"], &["searched"], &["searches"], + &["searching"], + &["searchkey"], + &["searchable"], &["seahawks"], &["seahawks"], &["seahawks"], @@ -16786,9 +33162,14 @@ pub static WORD_SEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["seamlessly"], &["senator"], &["senators"], + &["searchable"], &["searched"], + &["search", "searched"], + &["searchable"], + &["searching"], &["searching"], &["searches"], + &["search"], ], range: 2..=8, }; @@ -16801,7 +33182,7 @@ static WORD_SC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_SCA_NODE), None, - None, + Some(&WORD_SCC_NODE), None, Some(&WORD_SCE_NODE), None, @@ -16809,7 +33190,7 @@ static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_SCH_NODE), Some(&WORD_SCI_NODE), None, - None, + Some(&WORD_SCK_NODE), Some(&WORD_SCL_NODE), None, Some(&WORD_SCN_NODE), @@ -16845,24 +33226,44 @@ static WORD_SCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], + &["successfully"], + &["sculpture", "sculptor"], + &["sculptors", "sculptures"], &["sculpture"], &["sculpture"], &["sculpture"], &["sculpture"], + &["sculpt"], + &["sculpted"], + &["sculpting"], &["sculpture"], &["sculptures"], &["scrutiny"], ], - range: 5..=6, + range: 2..=9, }; static WORD_SCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -16871,54 +33272,256 @@ static WORD_SCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("osman")], - values: &[&["scotsman"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("ional"), + dictgen::InsensitiveStr::Ascii("ioned"), + dictgen::InsensitiveStr::Ascii("ioning"), + dictgen::InsensitiveStr::Ascii("ions"), + dictgen::InsensitiveStr::Ascii("osman"), + ], + values: &[ + &["section", "suction"], + &["sectional", "suctional"], + &["sectioned", "suctioned"], + &["sectioning", "suctioning"], + &["sections", "suctions"], + &["scotsman"], + ], + range: 3..=6, }; static WORD_SCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SCR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_SCR_CHILDREN), value: None, }; -pub static WORD_SCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("acth"), - dictgen::InsensitiveStr::Ascii("acthed"), - dictgen::InsensitiveStr::Ascii("acthes"), - dictgen::InsensitiveStr::Ascii("acthing"), - dictgen::InsensitiveStr::Ascii("ambe"), - dictgen::InsensitiveStr::Ascii("ambeld"), - dictgen::InsensitiveStr::Ascii("ambleing"), - dictgen::InsensitiveStr::Ascii("amblies"), - dictgen::InsensitiveStr::Ascii("atchs"), - dictgen::InsensitiveStr::Ascii("athces"), - dictgen::InsensitiveStr::Ascii("eenshat"), - dictgen::InsensitiveStr::Ascii("eenshit"), - dictgen::InsensitiveStr::Ascii("eenshoot"), - dictgen::InsensitiveStr::Ascii("eenshoots"), - dictgen::InsensitiveStr::Ascii("eenwrighter"), - dictgen::InsensitiveStr::Ascii("iptores"), - dictgen::InsensitiveStr::Ascii("iptue"), - dictgen::InsensitiveStr::Ascii("ipturae"), - dictgen::InsensitiveStr::Ascii("iptus"), - dictgen::InsensitiveStr::Ascii("iputres"), - dictgen::InsensitiveStr::Ascii("itped"), - dictgen::InsensitiveStr::Ascii("itps"), - dictgen::InsensitiveStr::Ascii("itpures"), - dictgen::InsensitiveStr::Ascii("oates"), - dictgen::InsensitiveStr::Ascii("ollade"), - dictgen::InsensitiveStr::Ascii("olld"), - dictgen::InsensitiveStr::Ascii("opion"), - dictgen::InsensitiveStr::Ascii("pited"), - dictgen::InsensitiveStr::Ascii("pits"), - dictgen::InsensitiveStr::Ascii("uitny"), - dictgen::InsensitiveStr::Ascii("unity"), - dictgen::InsensitiveStr::Ascii("utiney"), - dictgen::InsensitiveStr::Ascii("utinity"), - dictgen::InsensitiveStr::Ascii("utinty"), + 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_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("ited"), + dictgen::InsensitiveStr::Ascii("its"), + ], + values: &[&["scripted"], &["scripts"]], + range: 3..=4, +}; + +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("opted"), + dictgen::InsensitiveStr::Ascii("opting"), + dictgen::InsensitiveStr::Ascii("opts"), + dictgen::InsensitiveStr::Ascii("opttype"), + dictgen::InsensitiveStr::Ascii("ping"), + dictgen::InsensitiveStr::Ascii("pst"), + 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("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"), + ], + values: &[ + &["scripted"], + &["scripting"], + &["scripts"], + &["scripttype"], + &["scripting"], + &["scripts"], + &["scriptures"], + &["scriptures"], + &["scriptures"], + &["scripts"], + &["scripttype"], + &["scriptures"], + &["script"], + &["scripted"], + &["scripting"], + &["scripts"], + &["script"], + &["scripts"], + &["scriptures"], + ], + range: 2..=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("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: &[ + &["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"], @@ -16927,34 +33530,11 @@ pub static WORD_SCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["scrambled"], &["scrambling"], &["scramble"], + &["scrap"], &["scratches"], &["scratches"], - &["screenshot"], - &["screenshot"], - &["screenshot"], - &["screenshot"], - &["screenwriter"], - &["scriptures"], - &["scriptures"], - &["scriptures"], - &["scripts"], - &["scriptures"], - &["scripted"], - &["scripts"], - &["scriptures"], - &["socrates"], - &["scrolled"], - &["scrolled"], - &["scorpion"], - &["scripted"], - &["scripts"], - &["scrutiny"], - &["scrutiny"], - &["scrutiny"], - &["scrutiny"], - &["scrutiny"], ], - range: 4..=11, + range: 1..=7, }; static WORD_SCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -16975,14 +33555,18 @@ static WORD_SCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -16990,23 +33574,35 @@ pub static WORD_SCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["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, }; @@ -17020,10 +33616,16 @@ pub static WORD_SCN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("adinavia"), dictgen::InsensitiveStr::Ascii("adinavian"), + dictgen::InsensitiveStr::Ascii("eario"), dictgen::InsensitiveStr::Ascii("earios"), ], - values: &[&["scandinavia"], &["scandinavian"], &["scenarios"]], - range: 6..=9, + values: &[ + &["scandinavia"], + &["scandinavian"], + &["scenario"], + &["scenarios"], + ], + range: 5..=9, }; static WORD_SCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17032,9 +33634,28 @@ static WORD_SCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_SCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("upture")], - values: &[&["sculpture"]], - range: 6..=6, + 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 { @@ -17049,16 +33670,33 @@ pub static WORD_SCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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: &[ @@ -17067,19 +33705,36 @@ pub static WORD_SCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sciences"], &["scientists"], &["scientific"], + &["scientifically"], + &["scientifically"], + &["scientifically"], &["scientific"], &["scientists"], &["scientific"], &["scientifically"], &["scientifically"], + &["scientifically"], + &["scientifically"], + &["scientifically"], &["scientist"], &["scientist"], + &["scientists", "scientist"], + &["scientist"], &["science"], &["science"], + &["scintillation"], + &["scintillaqt"], + &["script", "skipped"], + &["scripted"], + &["scripting"], + &["scripts", "skips"], &["script"], + &["scripts"], + &["script"], + &["scripts"], &["scriptures"], ], - range: 3..=10, + range: 2..=11, }; static WORD_SCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17089,8 +33744,18 @@ static WORD_SCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("eems"), dictgen::InsensitiveStr::Ascii("eudling"), @@ -17104,6 +33769,10 @@ pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -17119,6 +33788,7 @@ pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("olorships"), dictgen::InsensitiveStr::Ascii("oodle"), dictgen::InsensitiveStr::Ascii("oold"), + dictgen::InsensitiveStr::Ascii("ould"), dictgen::InsensitiveStr::Ascii("ozophrenia"), dictgen::InsensitiveStr::Ascii("ozophrenic"), dictgen::InsensitiveStr::Ascii("yzophrenia"), @@ -17128,7 +33798,17 @@ pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["schedule"], + &["scheduled"], &["scheduling"], + &["scheduler"], + &["schedules"], + &["scheduling"], + &["schedule"], + &["scheduled"], + &["scheduled"], + &["scheduling"], + &["scheduling"], + &["scheduler"], &["scheduling"], &["schemes"], &["scheduling"], @@ -17142,14 +33822,18 @@ pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["schizophrenic"], &["schizophrenia"], &["schizophrenic"], + &["scheme"], + &["schema"], + &["schemas"], + &["schemes"], &["scholars"], &["scholarships"], &["scholarly"], &["scholarship"], - &["scholarship"], + &["scholarship", "scholarships"], &["scholarships"], &["scholarly"], - &["scholastic"], + &["scholastic", "scholarly"], &["scholarly"], &["scholarship"], &["scholarships"], @@ -17157,6 +33841,7 @@ pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["scholarships"], &["schooled"], &["schooled"], + &["should"], &["schizophrenia"], &["schizophrenic"], &["schizophrenia"], @@ -17164,7 +33849,7 @@ pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["schizophrenia"], &["schizophrenic"], ], - range: 4..=12, + range: 2..=12, }; static WORD_SCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17174,125 +33859,182 @@ static WORD_SCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("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("tch"), + dictgen::InsensitiveStr::Ascii("tched"), + dictgen::InsensitiveStr::Ascii("tches"), + dictgen::InsensitiveStr::Ascii("tching"), ], values: &[ + &["specified"], + &["scene", "seen", "screen", "scheme"], + &["scenes", "screens", "schemes"], &["scientific"], &["scientifically"], &["scientist"], &["scientists"], + &["scheme", "scene"], + &["schemes", "scenes"], + &["scenarios"], + &["scenario"], &["scenarios"], &["scenarios"], - &["scenarios"], + &["scene", "science", "sense"], + &["scenes", "sciences", "senses", "census"], + &["scenegraph"], + &["scenegraphs"], + &["second"], + &["seconds"], &["sceptre"], + &["sketch"], + &["sketched"], + &["sketches"], + &["sketching"], ], - range: 5..=11, + range: 2..=11, }; -static WORD_SCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_SCA_CHILDREN), +static WORD_SCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_SCC_CHILDREN), value: None, }; -pub static WORD_SCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_SCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("ope")], + values: &[&["scope"]], + range: 3..=3, +}; + +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), + None, + 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("epgoat"), - dictgen::InsensitiveStr::Ascii("leable"), - dictgen::InsensitiveStr::Ascii("ndales"), - dictgen::InsensitiveStr::Ascii("ndalos"), - dictgen::InsensitiveStr::Ascii("ndalosa"), - dictgen::InsensitiveStr::Ascii("ndalose"), - dictgen::InsensitiveStr::Ascii("ndalosi"), - dictgen::InsensitiveStr::Ascii("ndaloso"), - dictgen::InsensitiveStr::Ascii("ndanavia"), - dictgen::InsensitiveStr::Ascii("ndaniva"), - dictgen::InsensitiveStr::Ascii("ndanivia"), - dictgen::InsensitiveStr::Ascii("ndanivian"), - dictgen::InsensitiveStr::Ascii("ndas"), - dictgen::InsensitiveStr::Ascii("ndenavia"), - dictgen::InsensitiveStr::Ascii("ndenavian"), - dictgen::InsensitiveStr::Ascii("ndianvia"), - dictgen::InsensitiveStr::Ascii("ndianvian"), - dictgen::InsensitiveStr::Ascii("ndianvians"), - dictgen::InsensitiveStr::Ascii("ndimania"), - dictgen::InsensitiveStr::Ascii("ndinacian"), - dictgen::InsensitiveStr::Ascii("ndinaiva"), - dictgen::InsensitiveStr::Ascii("ndinaivan"), - dictgen::InsensitiveStr::Ascii("ndinava"), - dictgen::InsensitiveStr::Ascii("ndinavan"), - dictgen::InsensitiveStr::Ascii("ndinavica"), - dictgen::InsensitiveStr::Ascii("ndinavien"), - dictgen::InsensitiveStr::Ascii("ndinavion"), - dictgen::InsensitiveStr::Ascii("ndinvia"), - dictgen::InsensitiveStr::Ascii("ndivania"), - dictgen::InsensitiveStr::Ascii("ndivanian"), - dictgen::InsensitiveStr::Ascii("ndlas"), - dictgen::InsensitiveStr::Ascii("ndonavia"), - dictgen::InsensitiveStr::Ascii("ndonavian"), - dictgen::InsensitiveStr::Ascii("nnig"), - dictgen::InsensitiveStr::Ascii("nnign"), - dictgen::InsensitiveStr::Ascii("ntuary"), - dictgen::InsensitiveStr::Ascii("ramento"), - dictgen::InsensitiveStr::Ascii("ricity"), - dictgen::InsensitiveStr::Ascii("rifice"), - dictgen::InsensitiveStr::Ascii("rificed"), - dictgen::InsensitiveStr::Ascii("rifices"), - dictgen::InsensitiveStr::Ascii("rificing"), - dictgen::InsensitiveStr::Ascii("rmble"), - dictgen::InsensitiveStr::Ascii("rmbled"), - dictgen::InsensitiveStr::Ascii("rmbling"), - dictgen::InsensitiveStr::Ascii("rtch"), - dictgen::InsensitiveStr::Ascii("rtched"), - dictgen::InsensitiveStr::Ascii("rtches"), - dictgen::InsensitiveStr::Ascii("rtching"), - dictgen::InsensitiveStr::Ascii("teboarding"), - dictgen::InsensitiveStr::Ascii("vanged"), + 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: &[ - &["scapegoat"], - &["scalable"], - &["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"], - &["scanning"], - &["scanning"], - &["sanctuary"], &["sacramento"], + &["search", "scorch", "scratch"], &["scarcity"], &["sacrifice"], &["sacrificed"], @@ -17305,10 +34047,151 @@ pub static WORD_SCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["scratched"], &["scratches"], &["scratching"], - &["skateboarding"], - &["scavenged"], ], - range: 4..=10, + 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("arr"), + dictgen::InsensitiveStr::Ascii("eability"), + dictgen::InsensitiveStr::Ascii("eable"), + dictgen::InsensitiveStr::Ascii("eing"), + dictgen::InsensitiveStr::Ascii("led"), + ], + values: &[ + &["scalar"], + &["scalability"], + &["scalable"], + &["scaling"], + &["scaled"], + ], + range: 3..=8, +}; + +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_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 { @@ -17317,15 +34200,15 @@ static WORD_SA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, - None, + Some(&WORD_SAA_NODE), + Some(&WORD_SAB_NODE), Some(&WORD_SAC_NODE), Some(&WORD_SAD_NODE), - None, + Some(&WORD_SAE_NODE), Some(&WORD_SAF_NODE), None, None, - None, + Some(&WORD_SAI_NODE), None, Some(&WORD_SAK_NODE), Some(&WORD_SAL_NODE), @@ -17373,17 +34256,37 @@ pub static WORD_SAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict static WORD_SAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_SAV_CHILDREN), - value: None, + 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("ere"), + dictgen::InsensitiveStr::Ascii("ety"), + dictgen::InsensitiveStr::Ascii("group"), + dictgen::InsensitiveStr::Ascii("ve"), + dictgen::InsensitiveStr::Ascii("y"), ], - values: &[&["savanna"], &["savannah"], &["saving"]], - range: 4..=4, + values: &[ + &["savanna"], + &["savannah"], + &["saves"], + &["saving"], + &["svelte"], + &["safely"], + &["severe"], + &["safety"], + &["savegroup"], + &["save", "savvy", "salve"], + &["savvy"], + ], + range: 1..=5, }; static WORD_SAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17404,17 +34307,25 @@ static WORD_SAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("andard"), + dictgen::InsensitiveStr::Ascii("andards"), dictgen::InsensitiveStr::Ascii("asfaction"), dictgen::InsensitiveStr::Ascii("asfactory"), dictgen::InsensitiveStr::Ascii("elite"), dictgen::InsensitiveStr::Ascii("elites"), + dictgen::InsensitiveStr::Ascii("elitte"), dictgen::InsensitiveStr::Ascii("ellie"), dictgen::InsensitiveStr::Ascii("ellitte"), + dictgen::InsensitiveStr::Ascii("ement"), + dictgen::InsensitiveStr::Ascii("ements"), dictgen::InsensitiveStr::Ascii("erday"), dictgen::InsensitiveStr::Ascii("erdays"), + dictgen::InsensitiveStr::Ascii("ified"), dictgen::InsensitiveStr::Ascii("ifies"), dictgen::InsensitiveStr::Ascii("ifsy"), dictgen::InsensitiveStr::Ascii("ifsying"), + dictgen::InsensitiveStr::Ascii("ify"), + dictgen::InsensitiveStr::Ascii("ifying"), dictgen::InsensitiveStr::Ascii("isfaccion"), dictgen::InsensitiveStr::Ascii("isfacion"), dictgen::InsensitiveStr::Ascii("isfacory"), @@ -17425,11 +34336,19 @@ pub static WORD_SAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("isfactority"), dictgen::InsensitiveStr::Ascii("isfactorly"), dictgen::InsensitiveStr::Ascii("isfcation"), + dictgen::InsensitiveStr::Ascii("isfiabilty"), dictgen::InsensitiveStr::Ascii("isfiction"), + dictgen::InsensitiveStr::Ascii("isfing"), dictgen::InsensitiveStr::Ascii("isfiy"), + dictgen::InsensitiveStr::Ascii("isfyied"), dictgen::InsensitiveStr::Ascii("isifed"), dictgen::InsensitiveStr::Ascii("isifes"), + dictgen::InsensitiveStr::Ascii("isified"), + dictgen::InsensitiveStr::Ascii("isifies"), + dictgen::InsensitiveStr::Ascii("isify"), + dictgen::InsensitiveStr::Ascii("isifying"), dictgen::InsensitiveStr::Ascii("istactory"), + dictgen::InsensitiveStr::Ascii("istying"), dictgen::InsensitiveStr::Ascii("isy"), dictgen::InsensitiveStr::Ascii("ric"), dictgen::InsensitiveStr::Ascii("rical"), @@ -17445,21 +34364,33 @@ pub static WORD_SAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("sohi"), dictgen::InsensitiveStr::Ascii("telite"), dictgen::InsensitiveStr::Ascii("telites"), + dictgen::InsensitiveStr::Ascii("tellite"), + dictgen::InsensitiveStr::Ascii("tellites"), + dictgen::InsensitiveStr::Ascii("uaday"), + dictgen::InsensitiveStr::Ascii("uadays"), dictgen::InsensitiveStr::Ascii("uracion"), dictgen::InsensitiveStr::Ascii("urdsy"), ], values: &[ + &["standard"], + &["standards"], &["satisfaction"], &["satisfactory"], &["satellite"], &["satellites"], + &["satellite"], &["satellites"], &["satellites"], + &["statement"], + &["statements"], &["saturday"], &["saturdays"], + &["satisfied"], &["satisfies"], &["satisfy"], &["satisfying"], + &["satisfy"], + &["satisfying"], &["satisfaction"], &["satisfaction"], &["satisfactory"], @@ -17470,11 +34401,19 @@ pub static WORD_SAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["satisfactorily"], &["satisfactory"], &["satisfaction"], + &["satisfiability"], &["satisfaction"], + &["satisfying"], &["satisfy"], &["satisfied"], + &["satisfied"], &["satisfies"], + &["satisfied"], + &["satisfies"], + &["satisfy"], + &["satisfying"], &["satisfactory"], + &["satisfying"], &["satisfy"], &["satiric"], &["satirical"], @@ -17490,6 +34429,10 @@ pub static WORD_SAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["satoshi"], &["satellite"], &["satellites"], + &["satellite"], + &["satellites"], + &["saturday"], + &["saturdays"], &["saturation"], &["saturdays"], ], @@ -17517,6 +34460,7 @@ pub static WORD_SAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -17536,9 +34480,10 @@ pub static WORD_SAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["satisfied"], &["satisfies"], &["satisfying"], + &["satisfies"], &["sausage"], &["sausages"], - &["says"], + &["says", "sassy"], ], range: 1..=12, }; @@ -17560,6 +34505,7 @@ pub static WORD_SAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("castisch"), dictgen::InsensitiveStr::Ascii("gant"), dictgen::InsensitiveStr::Ascii("geant"), + dictgen::InsensitiveStr::Ascii("ting"), ], values: &[ &["sarcasm"], @@ -17572,6 +34518,7 @@ pub static WORD_SAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sarcastic"], &["sergeant"], &["sergeant"], + &["starting", "sorting"], ], range: 4..=10, }; @@ -17584,11 +34531,20 @@ static WORD_SAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("cebar"), + dictgen::InsensitiveStr::Ascii("hire"), + dictgen::InsensitiveStr::Ascii("hires"), dictgen::InsensitiveStr::Ascii("phie"), dictgen::InsensitiveStr::Ascii("phirre"), dictgen::InsensitiveStr::Ascii("phrie"), ], - values: &[&["spacebar"], &["sapphire"], &["sapphire"], &["sapphire"]], + values: &[ + &["spacebar"], + &["sapphire"], + &["sapphires"], + &["sapphire"], + &["sapphire"], + &["sapphire"], + ], range: 4..=6, }; @@ -17599,6 +34555,7 @@ static WORD_SAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("aty"), dictgen::InsensitiveStr::Ascii("ctiond"), dictgen::InsensitiveStr::Ascii("ctionne"), dictgen::InsensitiveStr::Ascii("ctionned"), @@ -17610,6 +34567,7 @@ pub static WORD_SAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -17617,17 +34575,28 @@ pub static WORD_SAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tcuary"), dictgen::InsensitiveStr::Ascii("tiation"), dictgen::InsensitiveStr::Ascii("tioned"), + 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"], &["sanctioned"], &["sanctioned"], &["sanctioned"], @@ -17639,6 +34608,7 @@ pub static WORD_SAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sandwiches"], &["sandals"], &["sanding"], + &["sandbox"], &["sandstorm"], &["sandstorm"], &["sandwiches"], @@ -17646,17 +34616,27 @@ pub static WORD_SAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sandwiches"], &["sanhedrin"], &["sanitation"], + &["sanitization"], + &["sanitizer"], &["sandler"], &["santorum"], &["sanctuary"], &["sanitation"], &["sanctioned"], + &["sanitize"], + &["sanitized"], + &["sanitizes"], + &["sanitizing"], &["santorum"], &["santorum"], &["santorum"], &["santorum"], + &["sandwich"], + &["sandwiches"], + &["sanitise"], + &["sanitize"], ], - range: 4..=9, + range: 3..=11, }; static WORD_SAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17667,19 +34647,33 @@ static WORD_SAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_SAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ckdown"), + dictgen::InsensitiveStr::Ascii("ll"), + dictgen::InsensitiveStr::Ascii("ller"), + dictgen::InsensitiveStr::Ascii("mon"), + dictgen::InsensitiveStr::Ascii("ori"), 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"], + &["small"], + &["smaller"], + &["salmon"], + &["samurai"], &["samples"], &["samurai"], &["samurai"], + &["same", "samuel"], &["samurai"], + &["sandwich"], + &["sandwiches"], ], - range: 4..=6, + range: 2..=6, }; static WORD_SAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17692,10 +34686,12 @@ pub static WORD_SAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], @@ -17703,10 +34699,12 @@ pub static WORD_SAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["salaries"], &["salaries"], &["salvage"], + &["salaries"], &["salary"], &["slaughter"], &["slaughtered"], &["slaughtering"], + &["slaveof"], &["slavery"], &["slaying"], ], @@ -17724,6 +34722,17 @@ pub static WORD_SAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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_SAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_SAF_CHILDREN), value: None, @@ -17731,11 +34740,41 @@ static WORD_SAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["safety"], &["safety"]], - range: 2..=3, + 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 { @@ -17748,6 +34787,7 @@ pub static WORD_SAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dends"), dictgen::InsensitiveStr::Ascii("denes"), dictgen::InsensitiveStr::Ascii("dnes"), + dictgen::InsensitiveStr::Ascii("e"), dictgen::InsensitiveStr::Ascii("isitc"), dictgen::InsensitiveStr::Ascii("istc"), dictgen::InsensitiveStr::Ascii("istisch"), @@ -17757,12 +34797,13 @@ pub static WORD_SAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["saddens"], &["saddens"], &["saddens"], + &["sad"], &["sadistic"], &["sadistic"], &["sadistic"], &["sanding"], ], - range: 4..=7, + range: 1..=7, }; static WORD_SAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -17772,9 +34813,13 @@ static WORD_SAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -17807,12 +34852,19 @@ pub static WORD_SAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -17845,9 +34897,37 @@ pub static WORD_SAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["sacrificed"], &["sacrifices"], &["sacrificing"], + &["sacrificing"], + &["sacrilegious"], + &["saccharin"], &["sacramento"], ], - range: 4..=10, + 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("atour"), + ], + values: &[&["sabotage"], &["saboteur"]], + range: 5..=5, +}; + +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 { @@ -17858,24 +34938,24 @@ static WORD_R_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_R_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_RA_NODE), None, - None, - None, + Some(&WORD_RC_NODE), + Some(&WORD_RD_NODE), Some(&WORD_RE_NODE), Some(&WORD_RF_NODE), - None, + Some(&WORD_RG_NODE), Some(&WORD_RH_NODE), Some(&WORD_RI_NODE), None, None, - None, - None, - None, + Some(&WORD_RL_NODE), + Some(&WORD_RM_NODE), + Some(&WORD_RN_NODE), Some(&WORD_RO_NODE), None, - None, - None, - None, - None, + 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), @@ -17892,6 +34972,7 @@ static WORD_RY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -17901,6 +34982,7 @@ pub static WORD_RY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg ], values: &[ &["reynolds"], + &["rsync"], &["resurrection"], &["rhythm"], &["rhythm"], @@ -17929,7 +35011,9 @@ static WORD_RU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -17939,10 +35023,24 @@ pub static WORD_RU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("lebok"), dictgen::InsensitiveStr::Ascii("leboook"), dictgen::InsensitiveStr::Ascii("lle"), + dictgen::InsensitiveStr::Ascii("matic"), dictgen::InsensitiveStr::Ascii("morus"), 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("nnning"), + dictgen::InsensitiveStr::Ascii("nns"), dictgen::InsensitiveStr::Ascii("nnung"), + dictgen::InsensitiveStr::Ascii("ntine"), + dictgen::InsensitiveStr::Ascii("nting"), + dictgen::InsensitiveStr::Ascii("rrent"), dictgen::InsensitiveStr::Ascii("slted"), dictgen::InsensitiveStr::Ascii("ssina"), dictgen::InsensitiveStr::Ascii("ssion"), @@ -17950,123 +35048,371 @@ pub static WORD_RU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("tgerus"), ], values: &[ + &["rhubarb"], &["recuperate"], &["rudimentary"], &["rudimentary"], &["rudimentary"], &["rudimentary"], + &["rudimentary"], &["rutgers"], &["rudimentary"], &["rulebook"], &["rulebook"], &["rule"], + &["rheumatic"], &["rumors"], &["rumors"], + &["running", "ruining"], + &["run"], + &["ran", "run", "ruined"], + &["running", "rummaging"], &["running"], &["running"], + &["running"], + &["running"], + &["running"], + &["running"], + &["runs"], + &["running"], + &["runtime", "routine"], + &["runtime"], + &["current"], &["rustled"], &["russian"], &["russian"], &["rustled"], &["rutgers"], ], - range: 3..=10, + range: 2..=10, }; -static WORD_RO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RO_CHILDREN), +static WORD_RT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_RT_CHILDREN), value: None, }; -pub static WORD_RO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_RT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("urns")], + values: &[&["returns", "turns"]], + range: 4..=4, +}; + +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("achers"), - dictgen::InsensitiveStr::Ascii("ahces"), - dictgen::InsensitiveStr::Ascii("aylties"), - dictgen::InsensitiveStr::Ascii("bberts"), - dictgen::InsensitiveStr::Ascii("bberys"), - dictgen::InsensitiveStr::Ascii("bocoop"), - dictgen::InsensitiveStr::Ascii("bocorp"), - dictgen::InsensitiveStr::Ascii("bocoup"), - dictgen::InsensitiveStr::Ascii("boticus"), - dictgen::InsensitiveStr::Ascii("botis"), - dictgen::InsensitiveStr::Ascii("ckerfeller"), - dictgen::InsensitiveStr::Ascii("cocco"), - dictgen::InsensitiveStr::Ascii("cord"), - dictgen::InsensitiveStr::Ascii("elplay"), - dictgen::InsensitiveStr::Ascii("estta"), - dictgen::InsensitiveStr::Ascii("ganism"), - dictgen::InsensitiveStr::Ascii("ganisms"), - dictgen::InsensitiveStr::Ascii("iters"), - dictgen::InsensitiveStr::Ascii("lepaly"), - dictgen::InsensitiveStr::Ascii("lepalying"), - dictgen::InsensitiveStr::Ascii("leplaing"), - dictgen::InsensitiveStr::Ascii("leply"), - dictgen::InsensitiveStr::Ascii("llarcoaster"), - dictgen::InsensitiveStr::Ascii("llercaoster"), - dictgen::InsensitiveStr::Ascii("llercoaser"), - dictgen::InsensitiveStr::Ascii("llercoater"), - dictgen::InsensitiveStr::Ascii("llercoaters"), - dictgen::InsensitiveStr::Ascii("llercoatser"), - dictgen::InsensitiveStr::Ascii("llerocaster"), - dictgen::InsensitiveStr::Ascii("llertoaster"), - dictgen::InsensitiveStr::Ascii("llorcoaster"), - dictgen::InsensitiveStr::Ascii("maanin"), - dictgen::InsensitiveStr::Ascii("maina"), - dictgen::InsensitiveStr::Ascii("mainan"), - dictgen::InsensitiveStr::Ascii("maing"), - dictgen::InsensitiveStr::Ascii("manain"), - dictgen::InsensitiveStr::Ascii("manica"), - dictgen::InsensitiveStr::Ascii("manin"), - dictgen::InsensitiveStr::Ascii("manitcally"), - dictgen::InsensitiveStr::Ascii("manmania"), - dictgen::InsensitiveStr::Ascii("manna"), - dictgen::InsensitiveStr::Ascii("manticaly"), - dictgen::InsensitiveStr::Ascii("omate"), - dictgen::InsensitiveStr::Ascii("settta"), - dictgen::InsensitiveStr::Ascii("staing"), - dictgen::InsensitiveStr::Ascii("tuers"), - dictgen::InsensitiveStr::Ascii("ugly"), - dictgen::InsensitiveStr::Ascii("undabaout"), - dictgen::InsensitiveStr::Ascii("undaboot"), - dictgen::InsensitiveStr::Ascii("undabount"), - dictgen::InsensitiveStr::Ascii("undabounts"), - dictgen::InsensitiveStr::Ascii("uteros"), - dictgen::InsensitiveStr::Ascii("yalites"), - dictgen::InsensitiveStr::Ascii("ylaties"), + dictgen::InsensitiveStr::Ascii("izing"), + dictgen::InsensitiveStr::Ascii("ource"), + dictgen::InsensitiveStr::Ascii("ourced"), + dictgen::InsensitiveStr::Ascii("ources"), + dictgen::InsensitiveStr::Ascii("ourcing"), + ], + values: &[ + &["resizing", "sizing"], + &["resource", "source"], + &["resourced", "sourced"], + &["resources", "sources"], + &["resourcing", "sourcing"], + ], + range: 5..=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"), + ], + values: &[&["translation"], &["translations"], &["erase"]], + 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_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), + None, + 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("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("tin"), + dictgen::InsensitiveStr::Ascii("tins"), + ], + values: &[ + &["rounding"], + &["roughly"], + &["roughly"], + &["routine"], + &["routines"], + &["roundabout"], + &["roundabout"], + &["roundabout"], + &["roundabout"], + &["rounding"], + &["roundtripped"], + &["roundtripping"], + &["roundtrip"], + &["routine"], + &["routines"], + &["roundtrip"], + &["roundtripped"], + &["roundtripping"], + &["roundtripped"], + &["roundtripping"], + &["routers"], + &["routed", "route", "router"], + &["routine", "routing"], + &["routines"], + ], + range: 3..=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("atio"), + dictgen::InsensitiveStr::Ascii("atios"), + dictgen::InsensitiveStr::Ascii("ats"), + dictgen::InsensitiveStr::Ascii("uers"), + ], + values: &[ + &["rotation"], + &["rotations"], + &["rotation"], + &["rotations"], + &["rotate"], + &["rotation"], + &["rotations"], + &["rotated", "rotate"], + &["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")], + values: &[&["repeat"]], + range: 3..=3, +}; + +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_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"), ], values: &[ - &["roaches"], - &["roaches"], - &["royalties"], - &["robbers"], - &["robbers"], - &["robocop"], - &["robocop"], - &["robocop"], - &["robotics"], - &["robotics"], - &["rockefeller"], - &["rococo"], - &["record"], - &["roleplay"], - &["rosetta"], - &["organism"], - &["organisms"], - &["rioters"], - &["roleplay"], - &["roleplaying"], - &["roleplaying"], - &["roleplay"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], - &["rollercoaster"], &["romanian"], &["romania"], &["romanian"], @@ -18078,107 +35424,426 @@ pub static WORD_RO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["romanian"], &["romanian"], &["romantically"], - &["roommate"], - &["rosetta"], - &["roasting"], - &["routers"], - &["roughly"], - &["roundabout"], - &["roundabout"], - &["roundabout"], - &["roundabout"], - &["routers"], - &["royalties"], - &["royalties"], ], - range: 4..=11, + range: 4..=9, }; -static WORD_RI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RI_CHILDREN), +static WORD_ROL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ROL_CHILDREN), value: None, }; -pub static WORD_RI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ROL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aders"), - dictgen::InsensitiveStr::Ascii("ctatorship"), - dictgen::InsensitiveStr::Ascii("dicilous"), - dictgen::InsensitiveStr::Ascii("dicilously"), - dictgen::InsensitiveStr::Ascii("dicilousness"), - dictgen::InsensitiveStr::Ascii("dicoulus"), - dictgen::InsensitiveStr::Ascii("dicoulusly"), - dictgen::InsensitiveStr::Ascii("dicoulusness"), - dictgen::InsensitiveStr::Ascii("diculious"), - dictgen::InsensitiveStr::Ascii("diculled"), - dictgen::InsensitiveStr::Ascii("diculos"), - dictgen::InsensitiveStr::Ascii("diculose"), - dictgen::InsensitiveStr::Ascii("diculosly"), - dictgen::InsensitiveStr::Ascii("diculouly"), - dictgen::InsensitiveStr::Ascii("diculouness"), - dictgen::InsensitiveStr::Ascii("diculoussness"), - dictgen::InsensitiveStr::Ascii("diculousy"), - dictgen::InsensitiveStr::Ascii("diculue"), - dictgen::InsensitiveStr::Ascii("diculued"), - dictgen::InsensitiveStr::Ascii("diculus"), - dictgen::InsensitiveStr::Ascii("enforced"), - dictgen::InsensitiveStr::Ascii("enforcement"), - dictgen::InsensitiveStr::Ascii("enforcements"), - dictgen::InsensitiveStr::Ascii("geur"), - dictgen::InsensitiveStr::Ascii("ghetous"), - dictgen::InsensitiveStr::Ascii("ghetousness"), - dictgen::InsensitiveStr::Ascii("ghteos"), - dictgen::InsensitiveStr::Ascii("ghteouness"), - dictgen::InsensitiveStr::Ascii("ghteoussness"), - dictgen::InsensitiveStr::Ascii("ghtfullly"), - dictgen::InsensitiveStr::Ascii("ghtfuly"), - dictgen::InsensitiveStr::Ascii("ghtiousness"), - dictgen::InsensitiveStr::Ascii("ghtoues"), - dictgen::InsensitiveStr::Ascii("gntone"), - dictgen::InsensitiveStr::Ascii("gourous"), - dictgen::InsensitiveStr::Ascii("gtheous"), - dictgen::InsensitiveStr::Ascii("gtheousness"), - dictgen::InsensitiveStr::Ascii("gthfully"), - dictgen::InsensitiveStr::Ascii("lvaries"), - dictgen::InsensitiveStr::Ascii("ngotne"), - dictgen::InsensitiveStr::Ascii("ninging"), - dictgen::InsensitiveStr::Ascii("sed"), - dictgen::InsensitiveStr::Ascii("talian"), - dictgen::InsensitiveStr::Ascii("tlain"), - dictgen::InsensitiveStr::Ascii("toers"), - dictgen::InsensitiveStr::Ascii("valrly"), - dictgen::InsensitiveStr::Ascii("varlies"), - dictgen::InsensitiveStr::Ascii("varly"), - dictgen::InsensitiveStr::Ascii("vlaries"), - dictgen::InsensitiveStr::Ascii("vlary"), + 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: &[ - &["raiders"], - &["dictatorship"], - &["ridiculous"], - &["ridiculously"], - &["ridiculousness"], - &["ridiculous"], - &["ridiculously"], - &["ridiculousness"], - &["ridiculous"], - &["ridicule"], - &["ridiculous"], - &["ridicule"], - &["ridiculously"], - &["ridiculously"], - &["ridiculousness"], - &["ridiculousness"], - &["ridiculously"], - &["ridicule"], - &["ridicule"], - &["ridiculous"], - &["reenforced"], - &["reinforcements"], - &["reinforcements"], - &["rigueur"], + &["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"), + ], + values: &[&["rockefeller"], &["rococo"], &["record"]], + 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"), + ], + values: &[ + &["robbers"], + &["robbers"], + &["robocop"], + &["robocop"], + &["robocop"], + &["robotics"], + &["robotics"], + &["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")], + values: &[&["relation"]], + range: 5..=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("lain"), + dictgen::InsensitiveStr::Ascii("oers"), + ], + values: &[&["writable"], &["ritalin"], &["ritalin"], &["rioters"]], + range: 4..=5, +}; + +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("pective"), + dictgen::InsensitiveStr::Ascii("trict"), + dictgen::InsensitiveStr::Ascii("tricted"), + dictgen::InsensitiveStr::Ascii("triction"), + ], + values: &[ + &["raised", "rose"], + &["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"), + ], + values: &[&["ringtone"], &["ringing"]], + range: 5..=6, +}; + +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("inder"), + dictgen::InsensitiveStr::Ascii("inders"), + dictgen::InsensitiveStr::Ascii("inding"), + dictgen::InsensitiveStr::Ascii("itives"), + ], + values: &[ + &["reminder"], + &["reminders"], + &["reminding"], + &["primitives"], + ], + range: 5..=6, +}; + +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("eur"), + dictgen::InsensitiveStr::Ascii("hetous"), + dictgen::InsensitiveStr::Ascii("hetousness"), + dictgen::InsensitiveStr::Ascii("hht"), + 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("ntone"), + 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: &[ + &["rigueur", "rigour", "rigour"], &["righteous"], &["righteousness"], + &["right"], &["righteous"], &["righteousness"], &["righteousness"], @@ -18188,23 +35853,101 @@ pub static WORD_RI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["righteous"], &["ringtone"], &["rigorous"], + &["right"], + &["right"], &["righteous"], &["righteousness"], &["rightfully"], - &["rivalries"], - &["ringtone"], - &["ringing"], - &["raised"], - &["ritalin"], - &["ritalin"], - &["rioters"], - &["rivalry"], - &["rivalries"], - &["rivalry"], - &["rivalries"], - &["rivalry"], + &["rights"], + &["rigorous"], ], - range: 3..=13, + 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("nforced"), + dictgen::InsensitiveStr::Ascii("nforcement"), + dictgen::InsensitiveStr::Ascii("nforcements"), + ], + values: &[&["reenforced"], &["reinforcements"], &["reinforcements"]], + range: 7..=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("tatorship")], + values: &[&["dictatorship"]], + range: 9..=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 { @@ -18223,6 +35966,7 @@ pub static WORD_RH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ymme"), dictgen::InsensitiveStr::Ascii("ythem"), dictgen::InsensitiveStr::Ascii("ythim"), + dictgen::InsensitiveStr::Ascii("ythimcally"), dictgen::InsensitiveStr::Ascii("ytmic"), ], values: &[ @@ -18235,9 +35979,21 @@ pub static WORD_RH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["rhyme"], &["rhythm"], &["rhythm"], + &["rhythmically"], &["rhythmic"], ], - range: 4..=8, + range: 4..=10, +}; + +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 { @@ -18246,9 +36002,13 @@ static WORD_RF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_RF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("erences")], - values: &[&["references"]], - range: 7..=7, + 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 { @@ -18266,7 +36026,7 @@ static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_REG_NODE), Some(&WORD_REH_NODE), Some(&WORD_REI_NODE), - None, + Some(&WORD_REJ_NODE), Some(&WORD_REK_NODE), Some(&WORD_REL_NODE), Some(&WORD_REM_NODE), @@ -18274,7 +36034,7 @@ static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_REO_NODE), Some(&WORD_REP_NODE), Some(&WORD_REQ_NODE), - None, + Some(&WORD_RER_NODE), Some(&WORD_RES_NODE), Some(&WORD_RET_NODE), Some(&WORD_REU_NODE), @@ -18325,12 +36085,22 @@ pub static WORD_REW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("atchig"), dictgen::InsensitiveStr::Ascii("atchign"), dictgen::InsensitiveStr::Ascii("atchimg"), + 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"], @@ -18340,87 +36110,259 @@ pub static WORD_REW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["rewatching"], &["rewatching"], &["rewatching"], + &["rewritable"], + &["rewrite"], + &["rewritten"], + &["rewritable"], &["rewrite"], &["rewritten"], &["reworked"], + &["rewritable", "reliable"], &["rewrite"], &["rewrite"], + &["rewrote", "rewritten"], + &["rewritten"], + &["rewrite"], + &["rewriting"], &["wretched"], + &["required"], ], - range: 4..=7, + range: 3..=7, }; static WORD_REV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REV_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_REV_CHILDREN), value: None, }; -pub static WORD_REV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ion")], + values: &[&["revision"]], + range: 3..=3, +}; + +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("aluated"), - dictgen::InsensitiveStr::Ascii("eald"), - dictgen::InsensitiveStr::Ascii("eales"), - dictgen::InsensitiveStr::Ascii("ealtion"), - dictgen::InsensitiveStr::Ascii("ealtions"), - dictgen::InsensitiveStr::Ascii("eiw"), - dictgen::InsensitiveStr::Ascii("eiwed"), - dictgen::InsensitiveStr::Ascii("eiwer"), - dictgen::InsensitiveStr::Ascii("eiwers"), - dictgen::InsensitiveStr::Ascii("eiws"), - dictgen::InsensitiveStr::Ascii("elaed"), - dictgen::InsensitiveStr::Ascii("elaing"), - dictgen::InsensitiveStr::Ascii("elaiton"), - dictgen::InsensitiveStr::Ascii("elaitons"), - dictgen::InsensitiveStr::Ascii("elance"), - dictgen::InsensitiveStr::Ascii("elant"), - dictgen::InsensitiveStr::Ascii("elas"), - dictgen::InsensitiveStr::Ascii("elatons"), - dictgen::InsensitiveStr::Ascii("elead"), - dictgen::InsensitiveStr::Ascii("elution"), - dictgen::InsensitiveStr::Ascii("elutionary"), - dictgen::InsensitiveStr::Ascii("eral"), - dictgen::InsensitiveStr::Ascii("erals"), - dictgen::InsensitiveStr::Ascii("ersable"), - dictgen::InsensitiveStr::Ascii("ersably"), - dictgen::InsensitiveStr::Ascii("iere"), - dictgen::InsensitiveStr::Ascii("iewd"), - dictgen::InsensitiveStr::Ascii("iewes"), - dictgen::InsensitiveStr::Ascii("iewr"), - dictgen::InsensitiveStr::Ascii("iewtrue"), - dictgen::InsensitiveStr::Ascii("isiones"), - dictgen::InsensitiveStr::Ascii("isionis"), - dictgen::InsensitiveStr::Ascii("lover"), - dictgen::InsensitiveStr::Ascii("loves"), - dictgen::InsensitiveStr::Ascii("olations"), - dictgen::InsensitiveStr::Ascii("oltuion"), - dictgen::InsensitiveStr::Ascii("oluiton"), - dictgen::InsensitiveStr::Ascii("olutin"), - dictgen::InsensitiveStr::Ascii("olutionair"), - dictgen::InsensitiveStr::Ascii("olutionairy"), - dictgen::InsensitiveStr::Ascii("olutionay"), - dictgen::InsensitiveStr::Ascii("olutionens"), - dictgen::InsensitiveStr::Ascii("olutioners"), - dictgen::InsensitiveStr::Ascii("olutionnary"), - dictgen::InsensitiveStr::Ascii("olutionos"), - dictgen::InsensitiveStr::Ascii("olutoin"), - dictgen::InsensitiveStr::Ascii("olvr"), - dictgen::InsensitiveStr::Ascii("olvs"), - dictgen::InsensitiveStr::Ascii("oultion"), - dictgen::InsensitiveStr::Ascii("oultionary"), - dictgen::InsensitiveStr::Ascii("oultions"), - dictgen::InsensitiveStr::Ascii("ovler"), - dictgen::InsensitiveStr::Ascii("ovles"), + dictgen::InsensitiveStr::Ascii("ese"), + dictgen::InsensitiveStr::Ascii("ieve"), + dictgen::InsensitiveStr::Ascii("ieves"), + ], + values: &[&["reverse"], &["retrieve"], &["retrieves"]], + range: 3..=5, +}; + +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("lations"), + dictgen::InsensitiveStr::Ascii("ltuion"), + dictgen::InsensitiveStr::Ascii("luion"), + dictgen::InsensitiveStr::Ascii("luiton"), + dictgen::InsensitiveStr::Ascii("lutin"), + dictgen::InsensitiveStr::Ascii("lutionair"), + dictgen::InsensitiveStr::Ascii("lutionairy"), + dictgen::InsensitiveStr::Ascii("lutionar"), + 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("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: &[ + &["revolutions"], + &["revolution"], + &["revolution"], + &["revolutions"], + &["revolutions"], + &["revolutionary"], + &["revolutionary"], + &["revolutionary"], + &["revolutionary"], + &["revolutions"], + &["revolutions"], + &["revolutionary"], + &["revolutions"], + &["revolutions"], + &["revolver"], + &["revolves"], + &["revolution"], + &["revolutionary"], + &["revolutions"], + &["revolver"], + &["revolves"], + ], + range: 3..=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("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("wed"), + dictgen::InsensitiveStr::Ascii("wer"), + dictgen::InsensitiveStr::Ascii("wers"), + dictgen::InsensitiveStr::Ascii("wing"), + ], + values: &[ + &["reviewer"], + &["reviewed"], + &["reviewers"], + &["reviewer"], + &["reviewsection"], + &["reviewer"], + &["revisions"], + &["revisions"], + &["revisions"], + &["revision"], + &["revisions"], + &["reviewed"], + &["reviewer"], + &["reviewers"], + &["reviewing"], + ], + range: 3..=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("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("rve"), + dictgen::InsensitiveStr::Ascii("rved"), + dictgen::InsensitiveStr::Ascii("wrse"), ], values: &[ - &["reevaluated"], &["revealed"], &["reveals"], &["revelations"], &["revelations"], + &["receive", "revive"], &["review"], &["reviewed"], &["reviewer"], &["reviewers"], + &["reviews", "reviewers"], + &["reviewing"], &["reviews"], &["revealed"], &["revealing"], @@ -18431,42 +36373,42 @@ pub static WORD_REV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["reveals"], &["revelations"], &["revealed"], + &["relevant"], &["revelation"], &["revolutionary"], + &["revokes"], + &["revert", "refer", "fever"], + &["reversal", "referral"], &["reversal"], - &["reversal"], + &["reverse"], + &["reversed"], + &["reference", "reverence"], + &["references"], + &["reverse"], + &["reversed"], + &["revert"], + &["reverted"], &["reversible"], &["reversal"], - &["reviewer"], - &["reviewed"], - &["reviewers"], - &["reviewer"], - &["reviewer"], - &["revisions"], - &["revisions"], - &["revolver"], - &["revolves"], - &["revolutions"], - &["revolution"], - &["revolutions"], - &["revolutions"], - &["revolutionary"], - &["revolutionary"], - &["revolutionary"], - &["revolutions"], - &["revolutions"], - &["revolutionary"], - &["revolutions"], - &["revolutions"], - &["revolver"], - &["revolves"], - &["revolution"], - &["revolutionary"], - &["revolutions"], - &["revolver"], - &["revolves"], + &["reserve"], + &["reserved"], + &["reverse"], ], - range: 3..=11, + 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 { @@ -18477,66 +36419,517 @@ static WORD_REU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("rn"), + dictgen::InsensitiveStr::Ascii("rsively"), + dictgen::InsensitiveStr::Ascii("slt"), + dictgen::InsensitiveStr::Ascii("ssing"), + dictgen::InsensitiveStr::Ascii("tnred"), + dictgen::InsensitiveStr::Ascii("trn"), + dictgen::InsensitiveStr::Ascii("trns"), ], - values: &[&["reusable"], &["reunion"], &["reputable"]], - range: 4..=6, + values: &[ + &["reusable"], + &["reduce"], + &["reduced"], + &["reduces"], + &["reduction"], + &["reductions"], + &["request"], + &["requests"], + &["reunion"], + &["regulator"], + &["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"], + &["return"], + &["recursively"], + &["result"], + &["reusing"], + &["returned"], + &["return"], + &["returns"], + ], + range: 2..=8, }; static WORD_RET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RET_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_RET_CHILDREN), value: None, }; -pub static WORD_RET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ailate"), - dictgen::InsensitiveStr::Ascii("ailation"), - dictgen::InsensitiveStr::Ascii("ailes"), - dictgen::InsensitiveStr::Ascii("alaite"), - dictgen::InsensitiveStr::Ascii("aliaton"), - dictgen::InsensitiveStr::Ascii("alier"), - dictgen::InsensitiveStr::Ascii("aliers"), - dictgen::InsensitiveStr::Ascii("alitated"), - dictgen::InsensitiveStr::Ascii("alitation"), - dictgen::InsensitiveStr::Ascii("ardathon"), - dictgen::InsensitiveStr::Ascii("ardating"), - dictgen::InsensitiveStr::Ascii("ardatron"), - dictgen::InsensitiveStr::Ascii("artation"), - dictgen::InsensitiveStr::Ascii("eriver"), - dictgen::InsensitiveStr::Ascii("horic"), - dictgen::InsensitiveStr::Ascii("horical"), - dictgen::InsensitiveStr::Ascii("ierment"), - dictgen::InsensitiveStr::Ascii("irase"), - dictgen::InsensitiveStr::Ascii("irbution"), - dictgen::InsensitiveStr::Ascii("ireds"), - dictgen::InsensitiveStr::Ascii("ireus"), - dictgen::InsensitiveStr::Ascii("ireve"), - dictgen::InsensitiveStr::Ascii("irever"), - dictgen::InsensitiveStr::Ascii("oractively"), - dictgen::InsensitiveStr::Ascii("rebution"), - dictgen::InsensitiveStr::Ascii("reive"), - dictgen::InsensitiveStr::Ascii("revier"), - dictgen::InsensitiveStr::Ascii("ribucion"), - dictgen::InsensitiveStr::Ascii("ribuito"), - dictgen::InsensitiveStr::Ascii("ribuiton"), - dictgen::InsensitiveStr::Ascii("ributioon"), - dictgen::InsensitiveStr::Ascii("ributivo"), - dictgen::InsensitiveStr::Ascii("ribvtion"), - dictgen::InsensitiveStr::Ascii("rived"), - dictgen::InsensitiveStr::Ascii("roactivelly"), - dictgen::InsensitiveStr::Ascii("roactivily"), - dictgen::InsensitiveStr::Ascii("roactivley"), - dictgen::InsensitiveStr::Ascii("roactivly"), - dictgen::InsensitiveStr::Ascii("robution"), - dictgen::InsensitiveStr::Ascii("rocatively"), - dictgen::InsensitiveStr::Ascii("rosepct"), - dictgen::InsensitiveStr::Ascii("rospekt"), - dictgen::InsensitiveStr::Ascii("rubution"), - dictgen::InsensitiveStr::Ascii("unred"), + 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("ring"), + dictgen::InsensitiveStr::Ascii("rm"), + dictgen::InsensitiveStr::Ascii("rmed"), + dictgen::InsensitiveStr::Ascii("rming"), + dictgen::InsensitiveStr::Ascii("rms"), + dictgen::InsensitiveStr::Ascii("rnd"), + dictgen::InsensitiveStr::Ascii("rnes"), + dictgen::InsensitiveStr::Ascii("rnig"), + dictgen::InsensitiveStr::Ascii("rnn"), + 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"], + &["returning"], + &["return"], + &["returned"], + &["returning"], + &["returns"], + &["returned"], + &["returns"], + &["returning"], + &["return"], + &["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::Flat(&WORD_RETR_CHILDREN), + value: None, +}; + +pub static WORD_RETR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("anser"), + dictgen::InsensitiveStr::Ascii("ansferd"), + dictgen::InsensitiveStr::Ascii("ansfered"), + dictgen::InsensitiveStr::Ascii("ansfering"), + dictgen::InsensitiveStr::Ascii("ansferrd"), + dictgen::InsensitiveStr::Ascii("ansfert"), + dictgen::InsensitiveStr::Ascii("ansmited"), + dictgen::InsensitiveStr::Ascii("ansmition"), + dictgen::InsensitiveStr::Ascii("ebution"), + dictgen::InsensitiveStr::Ascii("eevable"), + dictgen::InsensitiveStr::Ascii("eeval"), + dictgen::InsensitiveStr::Ascii("eeve"), + dictgen::InsensitiveStr::Ascii("eeved"), + dictgen::InsensitiveStr::Ascii("eeves"), + dictgen::InsensitiveStr::Ascii("eeving"), + dictgen::InsensitiveStr::Ascii("eivable"), + dictgen::InsensitiveStr::Ascii("eival"), + dictgen::InsensitiveStr::Ascii("eive"), + dictgen::InsensitiveStr::Ascii("eived"), + dictgen::InsensitiveStr::Ascii("eives"), + dictgen::InsensitiveStr::Ascii("eiving"), + dictgen::InsensitiveStr::Ascii("evable"), + dictgen::InsensitiveStr::Ascii("eval"), + dictgen::InsensitiveStr::Ascii("eve"), + dictgen::InsensitiveStr::Ascii("eved"), + dictgen::InsensitiveStr::Ascii("eves"), + dictgen::InsensitiveStr::Ascii("evier"), + dictgen::InsensitiveStr::Ascii("eving"), + dictgen::InsensitiveStr::Ascii("ibucion"), + dictgen::InsensitiveStr::Ascii("ibuito"), + dictgen::InsensitiveStr::Ascii("ibuiton"), + dictgen::InsensitiveStr::Ascii("ibutioon"), + dictgen::InsensitiveStr::Ascii("ibutivo"), + dictgen::InsensitiveStr::Ascii("ibvtion"), + dictgen::InsensitiveStr::Ascii("ict"), + dictgen::InsensitiveStr::Ascii("icted"), + dictgen::InsensitiveStr::Ascii("iebe"), + dictgen::InsensitiveStr::Ascii("iece"), + dictgen::InsensitiveStr::Ascii("ieces"), + dictgen::InsensitiveStr::Ascii("iev"), + dictgen::InsensitiveStr::Ascii("ieveds"), + dictgen::InsensitiveStr::Ascii("ival"), + dictgen::InsensitiveStr::Ascii("ive"), + dictgen::InsensitiveStr::Ascii("ived"), + dictgen::InsensitiveStr::Ascii("ives"), + dictgen::InsensitiveStr::Ascii("iving"), + dictgen::InsensitiveStr::Ascii("oactivelly"), + dictgen::InsensitiveStr::Ascii("oactivily"), + dictgen::InsensitiveStr::Ascii("oactivley"), + dictgen::InsensitiveStr::Ascii("oactivly"), + dictgen::InsensitiveStr::Ascii("obution"), + dictgen::InsensitiveStr::Ascii("ocatively"), + dictgen::InsensitiveStr::Ascii("osepct"), + dictgen::InsensitiveStr::Ascii("ospekt"), + dictgen::InsensitiveStr::Ascii("ubution"), + dictgen::InsensitiveStr::Ascii("un"), + dictgen::InsensitiveStr::Ascii("uned"), dictgen::InsensitiveStr::Ascii("uns"), - dictgen::InsensitiveStr::Ascii("urnd"), + ], + values: &[ + &["retransfer"], + &["retransferred"], + &["retransferred"], + &["retransferring"], + &["retransferred"], + &["retransfer", "retransferred"], + &["retransmitted"], + &["retransmission"], + &["retribution"], + &["retrievable"], + &["retrieval"], + &["retrieve"], + &["retrieved"], + &["retrieves"], + &["retrieving"], + &["retrievable"], + &["retrieval"], + &["retrieve"], + &["retrieved"], + &["retrieves"], + &["retrieving"], + &["retrievable"], + &["retrieval"], + &["retrieve"], + &["retrieved"], + &["retrieves"], + &["retriever"], + &["retrieving"], + &["retribution"], + &["retribution"], + &["retribution"], + &["retribution"], + &["retribution"], + &["retribution"], + &["restrict"], + &["restricted"], + &["retrieve"], + &["retrieve"], + &["retrieves"], + &["retrieve"], + &["retrieved"], + &["retrieval", "retrial"], + &["retrieve"], + &["retrieved"], + &["retrieves"], + &["retrieving"], + &["retroactively"], + &["retroactively"], + &["retroactively"], + &["retroactively"], + &["retribution"], + &["retroactively"], + &["retrospect"], + &["retrospect"], + &["retribution"], + &["return"], + &["returned"], + &["returns"], + ], + range: 2..=10, +}; + +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("rever"), + dictgen::InsensitiveStr::Ascii("reving"), + dictgen::InsensitiveStr::Ascii("rned"), + ], + values: &[ + &["retirement"], + &["retrieve"], + &["retrieved"], + &["retrieves"], + &["retrieving"], + &["retinue"], + &["retires"], + &["retribution"], + &["retires"], + &["retires"], + &["retrieve"], + &["retriever"], + &["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("ieves")], + values: &[&["retrieves", "receives"]], + range: 5..=5, +}; + +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("rtation"), ], values: &[ &["retaliate"], @@ -18548,45 +36941,14 @@ pub static WORD_RET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["retailers"], &["retaliated"], &["retaliation"], + &["rectangles"], + &["retranslate"], &["retardation"], &["retardation"], &["retardation"], &["retardation"], - &["retriever"], - &["rhetoric"], - &["rhetorical"], - &["retirement"], - &["retires"], - &["retribution"], - &["retires"], - &["retires"], - &["retrieve"], - &["retriever"], - &["retroactively"], - &["retribution"], - &["retrieve"], - &["retriever"], - &["retribution"], - &["retribution"], - &["retribution"], - &["retribution"], - &["retribution"], - &["retribution"], - &["retrieved"], - &["retroactively"], - &["retroactively"], - &["retroactively"], - &["retroactively"], - &["retribution"], - &["retroactively"], - &["retrospect"], - &["retrospect"], - &["retribution"], - &["returned"], - &["returns"], - &["returned"], ], - range: 3..=11, + range: 4..=8, }; static WORD_RES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -18611,18 +36973,29 @@ static WORD_RES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_RESO_NODE), Some(&WORD_RESP_NODE), - None, - None, + Some(&WORD_RESQ_NODE), + Some(&WORD_RESR_NODE), Some(&WORD_RESS_NODE), Some(&WORD_REST_NODE), Some(&WORD_RESU_NODE), None, 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, @@ -18631,23 +37004,79 @@ static WORD_RESU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_RESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("able"), + 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("l"), + dictgen::InsensitiveStr::Ascii("ling"), + dictgen::InsensitiveStr::Ascii("lotion"), + dictgen::InsensitiveStr::Ascii("lsets"), + 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("ts"), ], values: &[ &["reusable"], + &["resubstitution"], &["rescued"], &["rescues"], + &["reduction"], + &["reuse", "rescue"], + &["reused", "rescued"], + &["result"], + &["resulting"], + &["resolution"], + &["resultsets"], + &["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"], + &["results"], ], - range: 3..=8, + range: 1..=9, }; static WORD_REST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -18693,20 +37122,26 @@ pub static WORD_RESTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("rn"), + dictgen::InsensitiveStr::Ascii("rns"), ], values: &[ &["restaurant"], &["restaurants"], + &["restructuring"], &["restaurant"], &["restaurants"], &["restaurant"], &["restaurants"], + &["return"], + &["returns"], ], - range: 4..=6, + range: 2..=7, }; static WORD_RESTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -18725,10 +37160,13 @@ pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("aunt"), 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"), @@ -18752,6 +37190,7 @@ pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -18763,13 +37202,16 @@ pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["restrained"], &["restraining"], &["restraint"], - &["restraint"], + &["restraint", "restaurant"], &["restricted"], &["restriction"], + &["restricted"], &["restarting"], + &["restructure"], &["restrictive"], &["restraint"], &["restriction"], + &["restricted"], &["restricting"], &["restriction"], &["restricting"], @@ -18793,6 +37235,7 @@ pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["restriction"], &["restrictive"], &["restrictive"], + &["restoring"], &["restricted"], &["restricting"], &["restriction"], @@ -18807,20 +37250,38 @@ static WORD_RESTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[ - &["restoration"], + &["restoring"], + &["restoring"], + &["restore"], &["restoration"], &["restoration"], &["restored"], + &["restoration"], + &["restored"], + &["restorable"], + &["restorable"], + &["restoring"], + &["restores"], &["restarting"], + &["restoration"], ], - range: 2..=6, + range: 1..=7, }; static WORD_RESTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -18855,9 +37316,16 @@ pub static WORD_RESTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("raunt"), dictgen::InsensitiveStr::Ascii("raunts"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("sting"), ], - values: &[&["restaurant"], &["restaurants"]], - range: 5..=6, + values: &[ + &["restaurant"], + &["restaurants"], + &["reset"], + &["retesting"], + ], + range: 1..=6, }; static WORD_RESTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -18884,14 +37352,16 @@ pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], + &["restauranteur", "restauranteur"], + &["restauranteurs", "restauranteurs"], &["restaurants"], &["restaurant"], &["restaurants"], @@ -18903,6 +37373,8 @@ pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["restaurant"], &["restaurants"], &["restarting"], + &["restaurant"], + &["restaurant"], ], range: 3..=9, }; @@ -18914,41 +37386,99 @@ static WORD_RESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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("ult"), dictgen::InsensitiveStr::Ascii("urect"), dictgen::InsensitiveStr::Ascii("urected"), + dictgen::InsensitiveStr::Ascii("urecting"), dictgen::InsensitiveStr::Ascii("urection"), + dictgen::InsensitiveStr::Ascii("urects"), dictgen::InsensitiveStr::Ascii("urrection"), ], values: &[ + &["recipe"], &["resemblance"], &["resemble"], &["resembled"], &["resemblance"], &["resembling"], + &["resemble"], + &["resetting"], &["resists"], + &["resize"], + &["resizes"], + &["resource"], + &["resourced"], + &["resources"], + &["resourcing"], &["resurrecting"], + &["result"], &["resurrect"], &["resurrected"], + &["resurrecting"], &["resurrection"], + &["resurrects"], &["resurrection"], ], range: 3..=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] = [ - None, + Some(&WORD_RESPA_NODE), None, None, None, @@ -18961,7 +37491,7 @@ static WORD_RESP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_RESPN_NODE), Some(&WORD_RESPO_NODE), None, None, @@ -18999,82 +37529,180 @@ pub static WORD_RESPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_RESPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RESPO_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_RESPO_CHILDREN), value: None, }; -pub static WORD_RESPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("nce"), - dictgen::InsensitiveStr::Ascii("nces"), - dictgen::InsensitiveStr::Ascii("ncibilities"), - dictgen::InsensitiveStr::Ascii("ncibility"), - dictgen::InsensitiveStr::Ascii("ncible"), - dictgen::InsensitiveStr::Ascii("ncibly"), - dictgen::InsensitiveStr::Ascii("ncive"), - dictgen::InsensitiveStr::Ascii("ndas"), - dictgen::InsensitiveStr::Ascii("ndendo"), - dictgen::InsensitiveStr::Ascii("ndis"), - dictgen::InsensitiveStr::Ascii("ndus"), + 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("ned"), dictgen::InsensitiveStr::Ascii("nes"), - dictgen::InsensitiveStr::Ascii("nibilities"), - dictgen::InsensitiveStr::Ascii("nisbilities"), - dictgen::InsensitiveStr::Ascii("nisbility"), - dictgen::InsensitiveStr::Ascii("nisble"), - dictgen::InsensitiveStr::Ascii("nisbly"), - dictgen::InsensitiveStr::Ascii("nisve"), - dictgen::InsensitiveStr::Ascii("nnsibilty"), - dictgen::InsensitiveStr::Ascii("nsabile"), - dictgen::InsensitiveStr::Ascii("nsabilities"), - dictgen::InsensitiveStr::Ascii("nsability"), - dictgen::InsensitiveStr::Ascii("nsable"), - dictgen::InsensitiveStr::Ascii("nsably"), - dictgen::InsensitiveStr::Ascii("nsaveis"), - dictgen::InsensitiveStr::Ascii("nsbile"), - dictgen::InsensitiveStr::Ascii("nsbilty"), - dictgen::InsensitiveStr::Ascii("nsbily"), - dictgen::InsensitiveStr::Ascii("nsd"), - dictgen::InsensitiveStr::Ascii("nsebilities"), - dictgen::InsensitiveStr::Ascii("nsibe"), - dictgen::InsensitiveStr::Ascii("nsibel"), - dictgen::InsensitiveStr::Ascii("nsibil"), - dictgen::InsensitiveStr::Ascii("nsibile"), - dictgen::InsensitiveStr::Ascii("nsibilies"), - dictgen::InsensitiveStr::Ascii("nsibilites"), - dictgen::InsensitiveStr::Ascii("nsibilitys"), - dictgen::InsensitiveStr::Ascii("nsibiliy"), - dictgen::InsensitiveStr::Ascii("nsibillities"), - dictgen::InsensitiveStr::Ascii("nsibillity"), - dictgen::InsensitiveStr::Ascii("nsibilties"), - dictgen::InsensitiveStr::Ascii("nsibilty"), - dictgen::InsensitiveStr::Ascii("nsibily"), - dictgen::InsensitiveStr::Ascii("nsibities"), - dictgen::InsensitiveStr::Ascii("nsibley"), - dictgen::InsensitiveStr::Ascii("nsiblities"), - dictgen::InsensitiveStr::Ascii("nsiblity"), - dictgen::InsensitiveStr::Ascii("nsibliy"), - dictgen::InsensitiveStr::Ascii("nsiblty"), - dictgen::InsensitiveStr::Ascii("nsiby"), - dictgen::InsensitiveStr::Ascii("nsile"), - dictgen::InsensitiveStr::Ascii("nsing"), - dictgen::InsensitiveStr::Ascii("nsivle"), - dictgen::InsensitiveStr::Ascii("ratory"), - dictgen::InsensitiveStr::Ascii("sitories"), - dictgen::InsensitiveStr::Ascii("sitory"), - dictgen::InsensitiveStr::Ascii("ted"), - dictgen::InsensitiveStr::Ascii("ting"), ], 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::Flat(&WORD_RESPON_CHILDREN), + value: None, +}; + +pub static WORD_RESPON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("c"), + dictgen::InsensitiveStr::Ascii("ce"), + dictgen::InsensitiveStr::Ascii("ces"), + dictgen::InsensitiveStr::Ascii("cibilities"), + dictgen::InsensitiveStr::Ascii("cibility"), + dictgen::InsensitiveStr::Ascii("cible"), + dictgen::InsensitiveStr::Ascii("cibly"), + dictgen::InsensitiveStr::Ascii("cive"), + dictgen::InsensitiveStr::Ascii("das"), + dictgen::InsensitiveStr::Ascii("de"), + dictgen::InsensitiveStr::Ascii("dendo"), + dictgen::InsensitiveStr::Ascii("dis"), + dictgen::InsensitiveStr::Ascii("dus"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("ibilities"), + dictgen::InsensitiveStr::Ascii("isbilities"), + dictgen::InsensitiveStr::Ascii("isbility"), + dictgen::InsensitiveStr::Ascii("isble"), + dictgen::InsensitiveStr::Ascii("isbly"), + dictgen::InsensitiveStr::Ascii("isve"), + dictgen::InsensitiveStr::Ascii("nsibilty"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("sabile"), + dictgen::InsensitiveStr::Ascii("sabilities"), + dictgen::InsensitiveStr::Ascii("sability"), + dictgen::InsensitiveStr::Ascii("sable"), + dictgen::InsensitiveStr::Ascii("sably"), + dictgen::InsensitiveStr::Ascii("saveis"), + dictgen::InsensitiveStr::Ascii("sbile"), + dictgen::InsensitiveStr::Ascii("sbilty"), + dictgen::InsensitiveStr::Ascii("sbily"), + dictgen::InsensitiveStr::Ascii("sd"), + dictgen::InsensitiveStr::Ascii("sebilities"), + dictgen::InsensitiveStr::Ascii("sed"), + dictgen::InsensitiveStr::Ascii("ser"), + dictgen::InsensitiveStr::Ascii("sers"), + dictgen::InsensitiveStr::Ascii("sess"), + dictgen::InsensitiveStr::Ascii("sibe"), + dictgen::InsensitiveStr::Ascii("sibel"), + dictgen::InsensitiveStr::Ascii("sibil"), + dictgen::InsensitiveStr::Ascii("sibile"), + dictgen::InsensitiveStr::Ascii("sibilies"), + dictgen::InsensitiveStr::Ascii("sibilites"), + dictgen::InsensitiveStr::Ascii("sibilitys"), + dictgen::InsensitiveStr::Ascii("sibiliy"), + dictgen::InsensitiveStr::Ascii("sibillities"), + dictgen::InsensitiveStr::Ascii("sibillity"), + dictgen::InsensitiveStr::Ascii("sibilties"), + dictgen::InsensitiveStr::Ascii("sibilty"), + dictgen::InsensitiveStr::Ascii("sibily"), + dictgen::InsensitiveStr::Ascii("sibities"), + dictgen::InsensitiveStr::Ascii("sibley"), + dictgen::InsensitiveStr::Ascii("siblities"), + dictgen::InsensitiveStr::Ascii("siblity"), + dictgen::InsensitiveStr::Ascii("sibliy"), + dictgen::InsensitiveStr::Ascii("siblty"), + dictgen::InsensitiveStr::Ascii("siby"), + dictgen::InsensitiveStr::Ascii("sile"), + dictgen::InsensitiveStr::Ascii("sing"), + dictgen::InsensitiveStr::Ascii("sivle"), + ], + values: &[ + &["response", "respond"], + &["response"], + &["response", "responses"], &["responsibilities"], &["responsibility"], &["responsible"], &["responsibly"], &["responsive"], &["responds"], + &["respond", "response", "responds", "responded", "responder"], &["responded"], &["responds"], &["responds"], @@ -19088,6 +37716,7 @@ pub static WORD_RESPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["responsibly"], &["responsive"], &["responsibility"], + &["response", "respond"], &["responsible"], &["responsibilities"], &["responsibility"], @@ -19099,6 +37728,10 @@ pub static WORD_RESPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["responsibly"], &["responds"], &["responsibilities"], + &["responded", "responses"], + &["responder"], + &["responders"], + &["responses"], &["responsive"], &["responsibly"], &["responsibly"], @@ -19122,13 +37755,33 @@ pub static WORD_RESPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["responsive"], &["responding"], &["responsive"], - &["respiratory"], - &["repositories"], - &["repository"], - &["reposted"], - &["reposting"], ], - range: 2..=12, + range: 1..=11, +}; + +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 { @@ -19162,6 +37815,8 @@ pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -19190,6 +37845,8 @@ pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["respectable"], &["respective"], &["respectively"], + &["respective"], + &["respectively"], &["respectable"], &["respectable"], &["respective"], @@ -19217,67 +37874,301 @@ pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di range: 2..=8, }; -static WORD_RESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RESO_CHILDREN), +static WORD_RESPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_RESPA_CHILDREN), value: None, }; -pub static WORD_RESO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ltuion"), - dictgen::InsensitiveStr::Ascii("ltuions"), - dictgen::InsensitiveStr::Ascii("lucion"), - dictgen::InsensitiveStr::Ascii("lutin"), - dictgen::InsensitiveStr::Ascii("lutino"), - dictgen::InsensitiveStr::Ascii("lutionary"), - dictgen::InsensitiveStr::Ascii("lutoin"), - dictgen::InsensitiveStr::Ascii("lutons"), - dictgen::InsensitiveStr::Ascii("lvemos"), - dictgen::InsensitiveStr::Ascii("lvendo"), - dictgen::InsensitiveStr::Ascii("lveres"), - dictgen::InsensitiveStr::Ascii("lverse"), - dictgen::InsensitiveStr::Ascii("lviste"), - dictgen::InsensitiveStr::Ascii("lvs"), - dictgen::InsensitiveStr::Ascii("nabelt"), - dictgen::InsensitiveStr::Ascii("net"), - dictgen::InsensitiveStr::Ascii("ruces"), - dictgen::InsensitiveStr::Ascii("tration"), - dictgen::InsensitiveStr::Ascii("tred"), - dictgen::InsensitiveStr::Ascii("ultion"), - dictgen::InsensitiveStr::Ascii("ultions"), - dictgen::InsensitiveStr::Ascii("urse"), - dictgen::InsensitiveStr::Ascii("vle"), - dictgen::InsensitiveStr::Ascii("vled"), - dictgen::InsensitiveStr::Ascii("vles"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("le"), + dictgen::InsensitiveStr::Ascii("led"), + dictgen::InsensitiveStr::Ascii("les"), + ], + values: &[&["resolves"], &["resolve"], &["resolved"], &["resolves"]], + range: 2..=3, +}; + +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("rceype"), + dictgen::InsensitiveStr::Ascii("rcs"), + dictgen::InsensitiveStr::Ascii("rcse"), + dictgen::InsensitiveStr::Ascii("rcsed"), + dictgen::InsensitiveStr::Ascii("re"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("res"), + dictgen::InsensitiveStr::Ascii("rse"), + dictgen::InsensitiveStr::Ascii("tion"), ], values: &[ + &["resource"], + &["resourced"], + &["resources"], + &["resourcing"], + &["resolution"], + &["resolutions"], + &["resourced", "resource"], + &["resourced", "resource"], + &["resourcetype"], + &["resources", "resource"], + &["resources", "resource"], + &["resourced", "resource"], + &["resource"], + &["resourced"], + &["resources"], + &["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("red"), + ], + values: &[&["restoration"], &["restored"]], + range: 3..=6, +}; + +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("uce"), + dictgen::InsensitiveStr::Ascii("uced"), + dictgen::InsensitiveStr::Ascii("uces"), + dictgen::InsensitiveStr::Ascii("ucing"), + ], + values: &[ + &["resource"], + &["resourced"], + &["resources"], + &["resourcing"], + &["restore"], + &["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("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"], &["resolutions"], &["resolution"], &["resolutions"], &["resolutions"], + &["resolutions"], &["revolutionary"], &["resolutions"], - &["resolutions"], - &["resolves"], - &["resolved"], - &["resolves"], - &["resolves"], - &["resolves"], - &["resolves"], - &["resonate"], - &["resonate"], - &["resources"], - &["restoration"], - &["restored"], &["resolution"], &["resolutions"], - &["resources"], - &["resolve"], + &["resolves"], &["resolved"], &["resolves"], + &["resolves"], + &["resolving"], + &["resolves"], + &["resolves"], ], - range: 3..=9, + 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 { @@ -19301,12 +38192,24 @@ static WORD_RESL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["resolve"], &["resolved"], &["resolves"]], - range: 3..=4, + values: &[ + &["reselection"], + &["resolve"], + &["resolved"], + &["resolves"], + &["resolving"], + &["result"], + &["results"], + ], + range: 2..=6, }; static WORD_RESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19322,6 +38225,7 @@ pub static WORD_RESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -19352,6 +38256,8 @@ pub static WORD_RESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("stnaces"), dictgen::InsensitiveStr::Ascii("stribution"), dictgen::InsensitiveStr::Ascii("tsance"), + dictgen::InsensitiveStr::Ascii("vwar"), + dictgen::InsensitiveStr::Ascii("zeble"), ], values: &[ &["residential"], @@ -19360,6 +38266,7 @@ pub static WORD_RESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["residential"], &["residue"], &["residue"], + &["reiserfs"], &["resignation"], &["resignation"], &["resignment"], @@ -19390,6 +38297,8 @@ pub static WORD_RESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["resistances"], &["redistribution"], &["resistances"], + &["reservoir"], + &["resizable"], ], range: 4..=10, }; @@ -19403,8 +38312,15 @@ pub static WORD_RESG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ination"), dictgen::InsensitiveStr::Ascii("ined"), + dictgen::InsensitiveStr::Ascii("ister"), + dictgen::InsensitiveStr::Ascii("isters"), + ], + values: &[ + &["resignation"], + &["resigned"], + &["register"], + &["registers"], ], - values: &[&["resignation"], &["resigned"]], range: 4..=7, }; @@ -19415,8 +38331,17 @@ static WORD_RESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -19424,21 +38349,46 @@ pub static WORD_RESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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("voir"), ], values: &[ + &["research"], + &["researched"], &["researcher"], &["researchers"], + &["reservation"], + &["reservations"], + &["reserve"], + &["reserved"], + &["reserves"], + &["reserving"], + &["reselection"], &["resemble"], &["resemblance"], &["resembles"], @@ -19446,19 +38396,35 @@ pub static WORD_RESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["resemble"], &["resemblance"], &["resembles"], + &["recently"], + &["respect"], + &["respected"], + &["respecting"], + &["respective"], + &["respectively"], + &["respects"], &["receptionist"], &["research"], &["researched"], &["researchers"], &["researchers"], &["researching"], + &["reservation"], &["resurrection"], &["reserved"], &["reserved"], &["reserved"], + &["reset", "recessed"], + &["resetstatus"], + &["resettable"], + &["reset"], + &["resetting"], + &["reset"], + &["reserved"], + &["reserved"], &["reservoir"], ], - range: 3..=8, + range: 2..=9, }; static WORD_RESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19468,11 +38434,28 @@ static WORD_RESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("use"), ], - values: &[&["rescued"], &["rescues"]], - range: 3..=4, + values: &[ + &["rescanned"], + &["resource"], + &["resourced"], + &["resources"], + &["resourcing"], + &["restriction"], + &["restrictions"], + &["rescued"], + &["rescues"], + ], + range: 3..=7, }; static WORD_RESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19483,57 +38466,350 @@ static WORD_RESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["restaurant"]], - range: 3..=5, + values: &[ + &["respawn"], + &["research"], + &["restart"], + &["restarts"], + &["restaurant"], + &["restaurants"], + ], + range: 2..=6, }; -static WORD_REQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REQ_CHILDREN), +static WORD_RER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_RER_CHILDREN), value: None, }; -pub static WORD_REQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_RER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("iuem"), - dictgen::InsensitiveStr::Ascii("ueim"), - dictgen::InsensitiveStr::Ascii("ueriment"), - dictgen::InsensitiveStr::Ascii("uerimento"), - dictgen::InsensitiveStr::Ascii("ueriments"), - dictgen::InsensitiveStr::Ascii("uierment"), - dictgen::InsensitiveStr::Ascii("uierments"), - dictgen::InsensitiveStr::Ascii("uiers"), - dictgen::InsensitiveStr::Ascii("uieum"), - dictgen::InsensitiveStr::Ascii("uilme"), - dictgen::InsensitiveStr::Ascii("uime"), - dictgen::InsensitiveStr::Ascii("uirment"), - dictgen::InsensitiveStr::Ascii("ured"), - dictgen::InsensitiveStr::Ascii("urement"), - dictgen::InsensitiveStr::Ascii("uried"), - dictgen::InsensitiveStr::Ascii("uriements"), - dictgen::InsensitiveStr::Ascii("uries"), + dictgen::InsensitiveStr::Ascii("egisteration"), + dictgen::InsensitiveStr::Ascii("erences"), + dictgen::InsensitiveStr::Ascii("ference"), + dictgen::InsensitiveStr::Ascii("ferences"), + dictgen::InsensitiveStr::Ascii("pesentation"), + 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"], + &["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, + None, + 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("es"), + dictgen::InsensitiveStr::Ascii("est"), + dictgen::InsensitiveStr::Ascii("ested"), + dictgen::InsensitiveStr::Ascii("esting"), + dictgen::InsensitiveStr::Ascii("ests"), + dictgen::InsensitiveStr::Ascii("ied"), + 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"], + &["requires"], + &["request"], + &["requested"], + &["requesting"], + &["requests"], + &["required"], + &["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("reing"), + dictgen::InsensitiveStr::Ascii("remenet"), + dictgen::InsensitiveStr::Ascii("remenets"), + dictgen::InsensitiveStr::Ascii("remnt"), + dictgen::InsensitiveStr::Ascii("rment"), + dictgen::InsensitiveStr::Ascii("rments"), + dictgen::InsensitiveStr::Ascii("sit"), + dictgen::InsensitiveStr::Ascii("sits"), + ], + values: &[ + &["required"], + &["required"], + &["require"], + &["required"], + &["requirement"], + &["requirements"], + &["requires"], + &["requiring"], + &["requirements"], + &["requirements"], + &["requires"], + &["requires"], + &["request"], + &["requested"], + &["requesting"], + &["requests"], + &["requiem"], + &["requiem"], + &["requiem"], + &["requiring"], + &["requirement"], + &["requirements"], + &["requirement"], + &["requirement"], + &["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("im"), + 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("std"), + dictgen::InsensitiveStr::Ascii("stes"), + dictgen::InsensitiveStr::Ascii("stesd"), + dictgen::InsensitiveStr::Ascii("stested"), + dictgen::InsensitiveStr::Ascii("stests"), + dictgen::InsensitiveStr::Ascii("stied"), + dictgen::InsensitiveStr::Ascii("stying"), + dictgen::InsensitiveStr::Ascii("um"), ], values: &[ &["requiem"], - &["requiem"], - &["requirement"], - &["requirement"], - &["requirements"], - &["requirements"], - &["requirements"], - &["requires"], - &["requiem"], - &["requiem"], - &["requiem"], - &["requirement"], &["required"], &["requirement"], - &["required"], + &["requirement"], &["requirements"], - &["requires"], + &["request"], + &["request", "requisite"], + &["request"], + &["requested"], + &["requests", "requested"], + &["requested"], + &["requested"], + &["requests", "requested"], + &["requested"], + &["requesting"], + &["requiem"], ], - range: 4..=9, + range: 1..=7, +}; + +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("uem"), + dictgen::InsensitiveStr::Ascii("ure"), + ], + values: &[&["request"], &["requiem"], &["require"]], + range: 3..=3, +}; + +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("ust"), + dictgen::InsensitiveStr::Ascii("usted"), + dictgen::InsensitiveStr::Ascii("usting"), + dictgen::InsensitiveStr::Ascii("usts"), + ], + values: &[ + &["request"], + &["requested"], + &["requests"], + &["request"], + &["requested"], + &["requesting"], + &["requests"], + ], + range: 2..=6, }; static WORD_REP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19557,7 +38833,7 @@ static WORD_REP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_REPO_NODE), - None, + Some(&WORD_REPP_NODE), None, Some(&WORD_REPR_NODE), Some(&WORD_REPS_NODE), @@ -19680,6 +38956,7 @@ pub static WORD_REPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -19687,6 +38964,8 @@ pub static WORD_REPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("onsive"), dictgen::InsensitiveStr::Ascii("oted"), dictgen::InsensitiveStr::Ascii("ots"), + dictgen::InsensitiveStr::Ascii("pectively"), + dictgen::InsensitiveStr::Ascii("resents"), ], values: &[ &["respawn"], @@ -19702,6 +38981,7 @@ pub static WORD_REPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["responding"], &["responds"], &["response"], + &["responses"], &["responsibilities"], &["responsibility"], &["responsible"], @@ -19709,141 +38989,562 @@ pub static WORD_REPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["responsive"], &["reposted"], &["reposts"], + &["respectively"], + &["represents"], ], range: 3..=12, }; static WORD_REPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REPR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_REPR_CHILDREN), value: None, }; -pub static WORD_REPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ecussion"), - dictgen::InsensitiveStr::Ascii("ehenisble"), - dictgen::InsensitiveStr::Ascii("ehensable"), - dictgen::InsensitiveStr::Ascii("ehinsible"), - dictgen::InsensitiveStr::Ascii("esantation"), - dictgen::InsensitiveStr::Ascii("esantations"), - dictgen::InsensitiveStr::Ascii("esantative"), - dictgen::InsensitiveStr::Ascii("esantatives"), - dictgen::InsensitiveStr::Ascii("esenation"), - dictgen::InsensitiveStr::Ascii("esend"), - dictgen::InsensitiveStr::Ascii("esensible"), - dictgen::InsensitiveStr::Ascii("esentacion"), - dictgen::InsensitiveStr::Ascii("esentaciones"), - dictgen::InsensitiveStr::Ascii("esentaion"), - dictgen::InsensitiveStr::Ascii("esentaiton"), - dictgen::InsensitiveStr::Ascii("esentas"), - dictgen::InsensitiveStr::Ascii("esentate"), - dictgen::InsensitiveStr::Ascii("esentatie"), - dictgen::InsensitiveStr::Ascii("esentatief"), - dictgen::InsensitiveStr::Ascii("esentatieve"), - dictgen::InsensitiveStr::Ascii("esentatin"), - dictgen::InsensitiveStr::Ascii("esentating"), - dictgen::InsensitiveStr::Ascii("esentationen"), - dictgen::InsensitiveStr::Ascii("esentationer"), - dictgen::InsensitiveStr::Ascii("esentativas"), - dictgen::InsensitiveStr::Ascii("esentativo"), - dictgen::InsensitiveStr::Ascii("esenterad"), - dictgen::InsensitiveStr::Ascii("esentes"), - dictgen::InsensitiveStr::Ascii("esentetive"), - dictgen::InsensitiveStr::Ascii("esentetives"), - dictgen::InsensitiveStr::Ascii("esention"), - dictgen::InsensitiveStr::Ascii("esentitive"), - dictgen::InsensitiveStr::Ascii("esentitives"), - dictgen::InsensitiveStr::Ascii("esentitve"), - dictgen::InsensitiveStr::Ascii("esentive"), - dictgen::InsensitiveStr::Ascii("esentives"), - dictgen::InsensitiveStr::Ascii("esentn"), - dictgen::InsensitiveStr::Ascii("esentstion"), - dictgen::InsensitiveStr::Ascii("esentstive"), - dictgen::InsensitiveStr::Ascii("eset"), - dictgen::InsensitiveStr::Ascii("esetnation"), - dictgen::InsensitiveStr::Ascii("esnetation"), - dictgen::InsensitiveStr::Ascii("essent"), - dictgen::InsensitiveStr::Ascii("essin"), - dictgen::InsensitiveStr::Ascii("essivo"), - dictgen::InsensitiveStr::Ascii("esso"), - dictgen::InsensitiveStr::Ascii("esssion"), - dictgen::InsensitiveStr::Ascii("ezentative"), - dictgen::InsensitiveStr::Ascii("hase"), - dictgen::InsensitiveStr::Ascii("icussions"), - dictgen::InsensitiveStr::Ascii("ihensible"), - dictgen::InsensitiveStr::Ascii("oducable"), - dictgen::InsensitiveStr::Ascii("oduccion"), - dictgen::InsensitiveStr::Ascii("oducion"), - dictgen::InsensitiveStr::Ascii("oduciton"), - dictgen::InsensitiveStr::Ascii("oducive"), - dictgen::InsensitiveStr::Ascii("oducting"), - dictgen::InsensitiveStr::Ascii("oductivo"), - dictgen::InsensitiveStr::Ascii("oduktion"), - dictgen::InsensitiveStr::Ascii("toire"), + 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: &[ - &["repercussions"], - &["reprehensible"], - &["reprehensible"], - &["reprehensible"], + &["represent"], &["representation"], &["representations"], - &["representative"], - &["representatives"], - &["representation"], &["represented"], - &["reprehensible"], - &["representation"], - &["representations"], - &["representation"], - &["representations"], - &["represents"], - &["representative"], - &["representatives"], - &["representative"], - &["representative"], - &["representations"], - &["representation"], - &["representations"], - &["representations"], - &["representatives"], - &["representation"], - &["represented"], - &["represents"], - &["representative"], - &["representatives"], &["representing"], - &["representative"], - &["representatives"], - &["representative"], - &["representative"], - &["representatives"], - &["representing"], - &["representations"], - &["representatives"], &["represents"], - &["representations"], - &["representations"], - &["represents"], - &["repression"], - &["repression"], - &["repression"], - &["repression"], - &["representative"], - &["rephrase"], - &["repercussions"], - &["reprehensible"], + ], + 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("duciblity"), + dictgen::InsensitiveStr::Ascii("ducion"), + dictgen::InsensitiveStr::Ascii("duciton"), + dictgen::InsensitiveStr::Ascii("ducive"), + 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"], + &["reproducibility"], &["reproduction"], &["reproduction"], &["reproductive"], &["reproduction"], &["reproduction"], &["reproduction"], - &["repertoire"], + &["report"], + &["reports"], ], - range: 4..=12, + 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("etation"), + 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("ts"), + ], + values: &[ + &["represent"], + &["representations"], + &["represented"], + &["representing"], + &["represents"], + &["represent"], + &["representation"], + &["representative"], + &["represented"], + &["represents"], + ], + range: 1..=7, + }; + +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("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("tnation"), + ], + 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"], + &["representative"], + &["representatives"], + &["representative"], + &["representing"], + &["representative"], + &["representatives"], + &["representative"], + &["representative"], + &["representatives"], + &["representing"], + &["representations"], + &["representatives"], + &["represents"], + &["representation"], + &["representations"], + ], + 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"), + ], + values: &[ + &["represent"], + &["representation"], + &["representational"], + &["representations"], + ], + range: 4..=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")], + values: &[&["report"]], + range: 3..=3, }; static WORD_REPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19854,37 +39555,69 @@ static WORD_REPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_REPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("istory"), + 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("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("sitary"), + dictgen::InsensitiveStr::Ascii("sitiories"), dictgen::InsensitiveStr::Ascii("sitiory"), + dictgen::InsensitiveStr::Ascii("sitiroes"), + dictgen::InsensitiveStr::Ascii("sititioning"), + dictgen::InsensitiveStr::Ascii("sitorry"), + dictgen::InsensitiveStr::Ascii("sitry"), dictgen::InsensitiveStr::Ascii("sity"), + dictgen::InsensitiveStr::Ascii("soitory"), 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("stus"), + dictgen::InsensitiveStr::Ascii("te"), ], values: &[ &["repository"], + &["responding"], &["response"], + &["responses"], + &["responsibilities"], + &["responsibility"], &["responsible"], &["reproduction"], &["reproductive"], + &["reporting"], + &["repository"], &["reportedly"], &["reportedly"], &["reporters"], &["reporters"], &["reportedly"], + &["reporting"], + &["reportresources"], + &["repository"], + &["repository"], + &["repositories"], + &["repository"], + &["repositories"], + &["repositioning"], + &["repository"], &["repository"], &["repository"], &["repository"], @@ -19893,55 +39626,238 @@ pub static WORD_REPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["reposted"], &["reposts"], &["reposting"], + &["repositories"], &["repository"], &["reposts"], + &["report", "remote"], ], - range: 3..=8, + range: 2..=11, }; static WORD_REPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REPL_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_REPL_CHILDREN), value: None, }; -pub static WORD_REPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("acated"), - dictgen::InsensitiveStr::Ascii("aceble"), - dictgen::InsensitiveStr::Ascii("acemet"), - dictgen::InsensitiveStr::Ascii("acemnet"), - dictgen::InsensitiveStr::Ascii("acemnt"), - dictgen::InsensitiveStr::Ascii("acemnts"), - dictgen::InsensitiveStr::Ascii("acemtn"), - dictgen::InsensitiveStr::Ascii("ase"), - dictgen::InsensitiveStr::Ascii("ased"), - dictgen::InsensitiveStr::Ascii("ayd"), - dictgen::InsensitiveStr::Ascii("ayes"), - dictgen::InsensitiveStr::Ascii("eacable"), - dictgen::InsensitiveStr::Ascii("ecated"), - dictgen::InsensitiveStr::Ascii("icae"), - dictgen::InsensitiveStr::Ascii("ubic"), - dictgen::InsensitiveStr::Ascii("usive"), + 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"], + &["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"), + ], + values: &[&["replaceable"], &["replicated"]], + range: 5..=6, +}; + +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("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"], &["replacements"], &["replacements"], &["replacement"], &["replacements"], &["replacements"], - &["replaces"], - &["relapsed"], + &["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"], - &["replaceable"], - &["replicated"], - &["replicated"], - &["republic"], - &["repulsive"], ], - range: 3..=7, + range: 2..=8, }; static WORD_REPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19952,11 +39868,12 @@ static WORD_REPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_REPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("tition"), dictgen::InsensitiveStr::Ascii("tle"), dictgen::InsensitiveStr::Ascii("tles"), ], - values: &[&["rapid"], &["reptile"], &["reptiles"]], - range: 1..=4, + values: &[&["rapid"], &["repetition"], &["reptile"], &["reptiles"]], + range: 1..=6, }; static WORD_REPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -19994,24 +39911,51 @@ pub static WORD_REPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("atetly"), dictgen::InsensitiveStr::Ascii("atible"), dictgen::InsensitiveStr::Ascii("atidly"), + dictgen::InsensitiveStr::Ascii("atly"), + dictgen::InsensitiveStr::Ascii("ct"), dictgen::InsensitiveStr::Ascii("ctable"), + dictgen::InsensitiveStr::Ascii("cted"), + dictgen::InsensitiveStr::Ascii("cting"), dictgen::InsensitiveStr::Ascii("ctive"), dictgen::InsensitiveStr::Ascii("ctively"), + dictgen::InsensitiveStr::Ascii("cts"), + dictgen::InsensitiveStr::Ascii("dability"), + dictgen::InsensitiveStr::Ascii("dable"), dictgen::InsensitiveStr::Ascii("ition"), dictgen::InsensitiveStr::Ascii("ntable"), dictgen::InsensitiveStr::Ascii("ntence"), dictgen::InsensitiveStr::Ascii("ntent"), + dictgen::InsensitiveStr::Ascii("resent"), + dictgen::InsensitiveStr::Ascii("resentation"), + dictgen::InsensitiveStr::Ascii("resentational"), + dictgen::InsensitiveStr::Ascii("resentations"), + dictgen::InsensitiveStr::Ascii("resented"), + dictgen::InsensitiveStr::Ascii("resenting"), + dictgen::InsensitiveStr::Ascii("resents"), dictgen::InsensitiveStr::Ascii("rsentation"), dictgen::InsensitiveStr::Ascii("rsentations"), dictgen::InsensitiveStr::Ascii("rsented"), dictgen::InsensitiveStr::Ascii("rsenting"), dictgen::InsensitiveStr::Ascii("rsents"), + dictgen::InsensitiveStr::Ascii("rtoir"), + dictgen::InsensitiveStr::Ascii("sent"), + dictgen::InsensitiveStr::Ascii("sentation"), + dictgen::InsensitiveStr::Ascii("sentational"), + dictgen::InsensitiveStr::Ascii("sented"), + dictgen::InsensitiveStr::Ascii("senting"), + dictgen::InsensitiveStr::Ascii("sents"), + dictgen::InsensitiveStr::Ascii("t"), dictgen::InsensitiveStr::Ascii("tation"), + dictgen::InsensitiveStr::Ascii("tative"), + dictgen::InsensitiveStr::Ascii("te"), dictgen::InsensitiveStr::Ascii("teadly"), dictgen::InsensitiveStr::Ascii("tetion"), dictgen::InsensitiveStr::Ascii("ticion"), + dictgen::InsensitiveStr::Ascii("ting"), dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tions"), dictgen::InsensitiveStr::Ascii("titivo"), + dictgen::InsensitiveStr::Ascii("tive"), ], values: &[ &["repeatedly"], @@ -20028,26 +39972,53 @@ pub static WORD_REPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["repeatedly"], &["repeatable"], &["repeatedly"], - &["repeatable"], - &["receptive"], + &["repeatedly"], + &["respect"], + &["repeatable", "respectable"], + &["respected"], + &["respecting"], + &["receptive", "respective"], &["respectively"], + &["respects"], + &["repeatability"], + &["repeatable"], &["repetition"], &["repeatable"], &["repentance"], &["repentant"], + &["represent"], + &["representation"], + &["representational"], + &["representations"], + &["represented"], + &["representing"], + &["represents"], &["representation"], &["representations"], &["represented"], &["representing"], &["represents"], + &["repertoire"], + &["represent"], + &["representation"], + &["representational"], + &["represented"], + &["representing"], + &["represents"], + &["repeat"], &["repetition"], + &["repetitive"], + &["repeat"], &["repeatedly"], &["repetition"], &["repetition"], + &["repeating"], &["repetition"], + &["repetitions"], &["repetition"], + &["repetitive"], ], - range: 3..=11, + range: 1..=13, }; static WORD_REPB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20084,28 +40055,50 @@ static WORD_REPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ried"), dictgen::InsensitiveStr::Ascii("tition"), ], values: &[ + &["replace"], + &["replaced"], + &["replacement"], + &["replacements"], + &["replaces"], + &["replacing"], + &["repackage"], + &["repackaged"], &["repaired"], &["repairs"], + &["repaint"], &["replacement"], &["replacements"], &["replaces"], &["replaying"], &["replays"], + &["repaint", "repent"], + &["repaints", "repents"], &["repaired"], - &["repetition"], + &["repetition", "repartition"], ], - range: 3..=8, + range: 2..=8, }; static WORD_REO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20115,188 +40108,1287 @@ static WORD_REO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_REO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ccurrence"), + 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("uted"), dictgen::InsensitiveStr::Ascii("wrked"), ], - values: &[&["reorganisation"], &["reworked"]], - range: 5..=9, + values: &[ + &["recurrence"], + &["reoccurring", "recurring"], + &["reorder"], + &["removable"], + &["remove"], + &["removed"], + &["removes"], + &["removing"], + &["reopened"], + &["report"], + &["repository"], + &["record"], + &["reorder"], + &["reorder"], + &["reorganisation"], + &["reorganised"], + &["reorganized"], + &["reasonable"], + &["reason"], + &["resource"], + &["resourced"], + &["resources"], + &["resourcing"], + &["rounded"], + &["routed", "rerouted"], + &["reworked"], + ], + range: 2..=9, }; static WORD_REN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_REN_CHILDREN), value: None, }; -pub static WORD_REN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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("aiisance"), - dictgen::InsensitiveStr::Ascii("aiscance"), - dictgen::InsensitiveStr::Ascii("aissace"), - dictgen::InsensitiveStr::Ascii("aissaince"), - dictgen::InsensitiveStr::Ascii("aissanse"), - dictgen::InsensitiveStr::Ascii("aissence"), - dictgen::InsensitiveStr::Ascii("assaince"), - dictgen::InsensitiveStr::Ascii("assiance"), - dictgen::InsensitiveStr::Ascii("derd"), - dictgen::InsensitiveStr::Ascii("derered"), - dictgen::InsensitiveStr::Ascii("deres"), - dictgen::InsensitiveStr::Ascii("devous"), - dictgen::InsensitiveStr::Ascii("dezous"), - dictgen::InsensitiveStr::Ascii("eagde"), - dictgen::InsensitiveStr::Ascii("edered"), - dictgen::InsensitiveStr::Ascii("egae"), - dictgen::InsensitiveStr::Ascii("egated"), - dictgen::InsensitiveStr::Ascii("egerate"), - dictgen::InsensitiveStr::Ascii("egeration"), - dictgen::InsensitiveStr::Ascii("etkon"), - dictgen::InsensitiveStr::Ascii("ewabe"), - dictgen::InsensitiveStr::Ascii("ewabels"), - dictgen::InsensitiveStr::Ascii("ewebles"), - dictgen::InsensitiveStr::Ascii("ewl"), - dictgen::InsensitiveStr::Ascii("iassance"), - dictgen::InsensitiveStr::Ascii("iforcements"), - dictgen::InsensitiveStr::Ascii("keton"), - dictgen::InsensitiveStr::Ascii("mant"), - dictgen::InsensitiveStr::Ascii("mants"), - dictgen::InsensitiveStr::Ascii("novate"), - dictgen::InsensitiveStr::Ascii("novated"), - dictgen::InsensitiveStr::Ascii("novating"), - dictgen::InsensitiveStr::Ascii("novation"), - dictgen::InsensitiveStr::Ascii("oylds"), - dictgen::InsensitiveStr::Ascii("teris"), - dictgen::InsensitiveStr::Ascii("tors"), - dictgen::InsensitiveStr::Ascii("tres"), - dictgen::InsensitiveStr::Ascii("uion"), - dictgen::InsensitiveStr::Ascii("weables"), - dictgen::InsensitiveStr::Ascii("yolds"), + 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("ylds")], + values: &[&["reynolds"]], + range: 4..=4, +}; + +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("ovate"), + dictgen::InsensitiveStr::Ascii("ovated"), + dictgen::InsensitiveStr::Ascii("ovating"), + dictgen::InsensitiveStr::Ascii("ovation"), ], values: &[ - &["renaissance"], - &["renaissance"], - &["renaissance"], - &["renaissance"], - &["renaissance"], - &["renaissance"], - &["renaissance"], - &["renaissance"], - &["rendered"], - &["rendered"], - &["renders"], - &["rendezvous"], - &["rendezvous"], - &["renegade"], - &["rende"], - &["renegade"], - &["renegade"], - &["regenerate"], - &["regeneration"], - &["renekton"], - &["renewables"], - &["renewables"], - &["renewables"], - &["renewal"], - &["renaissance"], - &["reinforcements"], - &["renekton"], - &["remnant"], - &["remnants"], &["renovate"], &["renovated"], &["renovating"], &["renovation"], - &["reynolds"], - &["renters"], - &["renters"], - &["renters"], - &["reunion"], - &["renewables"], - &["reynolds"], ], - range: 3..=11, + range: 5..=7, }; -static WORD_REM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REM_CHILDREN), +static WORD_RENM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_RENM_CHILDREN), value: None, }; -pub static WORD_REM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_RENM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aind"), - dictgen::InsensitiveStr::Ascii("ainds"), - dictgen::InsensitiveStr::Ascii("aing"), - dictgen::InsensitiveStr::Ascii("ainig"), - dictgen::InsensitiveStr::Ascii("akrs"), - dictgen::InsensitiveStr::Ascii("annt"), - dictgen::InsensitiveStr::Ascii("annts"), - dictgen::InsensitiveStr::Ascii("arcably"), - dictgen::InsensitiveStr::Ascii("arkablely"), - dictgen::InsensitiveStr::Ascii("arkabley"), - dictgen::InsensitiveStr::Ascii("arkablly"), - dictgen::InsensitiveStr::Ascii("arkes"), - dictgen::InsensitiveStr::Ascii("arkibly"), - dictgen::InsensitiveStr::Ascii("asterd"), - dictgen::InsensitiveStr::Ascii("asterred"), - dictgen::InsensitiveStr::Ascii("eber"), - dictgen::InsensitiveStr::Ascii("embed"), - dictgen::InsensitiveStr::Ascii("embee"), - dictgen::InsensitiveStr::Ascii("emberance"), - dictgen::InsensitiveStr::Ascii("emberd"), - dictgen::InsensitiveStr::Ascii("emberes"), - dictgen::InsensitiveStr::Ascii("embrence"), - dictgen::InsensitiveStr::Ascii("emebr"), - dictgen::InsensitiveStr::Ascii("emebrs"), - dictgen::InsensitiveStr::Ascii("enant"), - dictgen::InsensitiveStr::Ascii("enicent"), - dictgen::InsensitiveStr::Ascii("ianing"), - dictgen::InsensitiveStr::Ascii("ians"), - dictgen::InsensitiveStr::Ascii("ifications"), - dictgen::InsensitiveStr::Ascii("ignton"), - dictgen::InsensitiveStr::Ascii("inent"), - dictgen::InsensitiveStr::Ascii("inescent"), - dictgen::InsensitiveStr::Ascii("ingotn"), - dictgen::InsensitiveStr::Ascii("inicient"), - dictgen::InsensitiveStr::Ascii("iniscant"), - dictgen::InsensitiveStr::Ascii("iniscient"), - dictgen::InsensitiveStr::Ascii("iniscint"), - dictgen::InsensitiveStr::Ascii("inisent"), - dictgen::InsensitiveStr::Ascii("inscent"), - dictgen::InsensitiveStr::Ascii("inscient"), - dictgen::InsensitiveStr::Ascii("insicent"), - dictgen::InsensitiveStr::Ascii("meber"), - dictgen::InsensitiveStr::Ascii("mebered"), - dictgen::InsensitiveStr::Ascii("mebers"), - dictgen::InsensitiveStr::Ascii("nans"), - dictgen::InsensitiveStr::Ascii("otelly"), - dictgen::InsensitiveStr::Ascii("otley"), + 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"), + ], + values: &[&["renaissance"], &["reinforcements"]], + range: 7..=10, +}; + +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("eradble"), + dictgen::InsensitiveStr::Ascii("erd"), + dictgen::InsensitiveStr::Ascii("ereing"), + 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"), + ], + values: &[ + &["renderable"], + &["rendered"], + &["rendering"], + &["rendered"], + &["renderers"], + &["rendering"], + &["renders", "renderers"], + &["rendering"], + &["render"], + &["rendering"], + &["rendezvous"], + &["rendezvous"], + &["rendered"], + &["renderer"], + &["renderers"], + &["rendering"], + ], + range: 3..=7, +}; + +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), + None, + 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("ed"), + dictgen::InsensitiveStr::Ascii("oe"), + dictgen::InsensitiveStr::Ascii("oed"), + dictgen::InsensitiveStr::Ascii("oved"), + ], + values: &[&["removed"], &["remove"], &["removed"], &["removed"]], + range: 2..=4, +}; + +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("ntly"), + dictgen::InsensitiveStr::Ascii("ote"), + dictgen::InsensitiveStr::Ascii("re"), + dictgen::InsensitiveStr::Ascii("rted"), + 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"], + &["remotely"], + &["remote"], + &["remote"], + &["reported"], + &["remotely"], + &["remotely"], + &["remove"], + &["removable"], + &["removeformat"], + &["removing"], + &["removed"], + ], + range: 2..=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("ebers"), + dictgen::InsensitiveStr::Ascii("ove"), + ], + values: &[&["remember"], &["remembered"], &["remembers"], &["remove"]], + range: 3..=6, +}; + +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("niscant"), + dictgen::InsensitiveStr::Ascii("niscense"), + dictgen::InsensitiveStr::Ascii("niscient"), + dictgen::InsensitiveStr::Ascii("niscint"), + dictgen::InsensitiveStr::Ascii("nisent"), + dictgen::InsensitiveStr::Ascii("nscent"), + dictgen::InsensitiveStr::Ascii("nscient"), + dictgen::InsensitiveStr::Ascii("nsicent"), + ], + values: &[ + &["remain"], + &["remainder", "reminder"], &["remained"], - &["remains"], - &["remaining"], - &["remaining"], - &["remarks"], - &["remnant"], - &["remnants"], - &["remarkably"], - &["remarkably"], - &["remarkably"], - &["remarkably"], - &["remarks"], - &["remarkably"], - &["remastered"], - &["remastered"], - &["remember"], - &["remembered"], - &["remembered"], - &["remembrance"], - &["remembered"], - &["remembers"], - &["remembrance"], - &["remember"], - &["remembers"], - &["remnant"], - &["reminiscent"], &["remaining"], &["remains"], &["ramifications"], @@ -20305,21 +41397,172 @@ pub static WORD_REM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["reminiscent"], &["remington"], &["reminiscent"], + &["remaining"], + &["reminiscent"], + &["reminiscence"], &["reminiscent"], &["reminiscent"], &["reminiscent"], &["reminiscent"], &["reminiscent"], &["reminiscent"], - &["reminiscent"], + ], + 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"), + ], + values: &[ + &["remember"], + &["remembered"], + &["remembering"], + &["remembers"], + &["remembered"], + &["remembered"], + &["memorable"], + &["remembrance"], + &["remembered"], + &["remembers"], + &["remembrance"], + &["remember"], + &["remembered"], + &["remembering"], + &["remembers"], &["remember"], &["remembered"], &["remembers"], - &["remnants"], - &["remotely"], - &["remotely"], + &["remember"], + &["remembered"], + &["remembers"], + &["remember"], + &["remembered"], + &["remembers"], + &["remember"], + &["remembered"], + &["remembering"], + &["remembers"], + &["remember"], + &["remnant"], + &["remember"], + &["reminiscent"], ], - range: 4..=10, + range: 3..=8, +}; + +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("ning"), + dictgen::InsensitiveStr::Ascii("nnt"), + dictgen::InsensitiveStr::Ascii("nnts"), + 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"], + &["remains"], + &["remainder"], + &["remains"], + &["remaining"], + &["remaining"], + &["remaining"], + &["remains"], + &["remarks"], + &["remaining"], + &["remnant"], + &["remnants"], + &["remapping"], + &["remarkably"], + &["remarkably"], + &["remarkably"], + &["remarkably"], + &["remarks"], + &["remarkably"], + &["remastered"], + &["remastered"], + ], + range: 3..=8, }; static WORD_REL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20339,23 +41582,46 @@ static WORD_REL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_RELI_NODE), None, None, + Some(&WORD_RELL_NODE), None, None, - None, - None, + Some(&WORD_RELO_NODE), Some(&WORD_RELP_NODE), None, None, None, - None, + Some(&WORD_RELT_NODE), Some(&WORD_RELU_NODE), None, 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, @@ -20379,6 +41645,17 @@ pub static WORD_RELU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -20389,9 +41666,73 @@ pub static WORD_RELP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("acement"), dictgen::InsensitiveStr::Ascii("ase"), dictgen::InsensitiveStr::Ascii("ased"), + dictgen::InsensitiveStr::Ascii("y"), ], - values: &[&["replacement"], &["relapse"], &["relapsed"]], - range: 3..=7, + 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_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 { @@ -20407,7 +41748,9 @@ pub static WORD_RELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ent"), dictgen::InsensitiveStr::Ascii("geous"), dictgen::InsensitiveStr::Ascii("geously"), @@ -20418,7 +41761,10 @@ pub static WORD_RELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), ], @@ -20429,7 +41775,9 @@ pub static WORD_RELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["reliability"], &["reliably"], &["reliably"], + &["reliability"], &["realised"], + &["rely", "relies", "really", "relief"], &["reliant"], &["religious"], &["religiously"], @@ -20440,11 +41788,14 @@ pub static WORD_RELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["religiously"], &["religious"], &["religiously"], + &["relinquish"], + &["relinquishing"], &["relinquishment"], + &["relinquish"], &["relatively"], - &["realized"], + &["realized", "realized"], ], - range: 3..=9, + range: 1..=9, }; static WORD_RELF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20483,7 +41834,22 @@ static WORD_RELE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_RELE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("aase"), + dictgen::InsensitiveStr::Ascii("aased"), + dictgen::InsensitiveStr::Ascii("ad"), dictgen::InsensitiveStr::Ascii("agtion"), + dictgen::InsensitiveStr::Ascii("ant"), + dictgen::InsensitiveStr::Ascii("as"), + dictgen::InsensitiveStr::Ascii("asead"), + dictgen::InsensitiveStr::Ascii("asse"), + dictgen::InsensitiveStr::Ascii("ated"), + dictgen::InsensitiveStr::Ascii("ating"), + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("ations"), + dictgen::InsensitiveStr::Ascii("ationship"), + dictgen::InsensitiveStr::Ascii("ationships"), + dictgen::InsensitiveStr::Ascii("ative"), + dictgen::InsensitiveStr::Ascii("cant"), dictgen::InsensitiveStr::Ascii("cted"), dictgen::InsensitiveStr::Ascii("gato"), dictgen::InsensitiveStr::Ascii("getion"), @@ -20495,16 +41861,39 @@ pub static WORD_RELE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ntlessley"), dictgen::InsensitiveStr::Ascii("ntlessy"), dictgen::InsensitiveStr::Ascii("ntness"), + dictgen::InsensitiveStr::Ascii("oad"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("sed"), dictgen::InsensitiveStr::Ascii("ses"), + dictgen::InsensitiveStr::Ascii("tive"), + dictgen::InsensitiveStr::Ascii("tively"), dictgen::InsensitiveStr::Ascii("tnless"), + dictgen::InsensitiveStr::Ascii("vabt"), + dictgen::InsensitiveStr::Ascii("vane"), dictgen::InsensitiveStr::Ascii("vation"), dictgen::InsensitiveStr::Ascii("vations"), + dictgen::InsensitiveStr::Ascii("veant"), dictgen::InsensitiveStr::Ascii("vence"), dictgen::InsensitiveStr::Ascii("vent"), dictgen::InsensitiveStr::Ascii("xation"), ], values: &[ + &["release"], + &["released"], + &["reload"], &["relegation"], + &["relevant", "relent"], + &["release"], + &["released"], + &["release"], + &["related"], + &["relating"], + &["relation"], + &["relations"], + &["relationship"], + &["relationships"], + &["relative"], + &["relevant"], &["reelected"], &["relegation"], &["relegation"], @@ -20516,15 +41905,23 @@ pub static WORD_RELE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["relentlessly"], &["relentlessly"], &["relentless"], + &["reload"], + &["release"], + &["released"], &["releases"], + &["relative"], + &["relatively"], &["relentless"], + &["relevant"], + &["relevant"], &["revelation"], &["revelations"], + &["relevant"], &["relevance"], &["relevant"], &["relegation"], ], - range: 3..=9, + range: 2..=10, }; static WORD_RELC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20543,80 +41940,144 @@ pub static WORD_RELC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_RELA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RELA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_RELA_CHILDREN), value: Some(&["real"]), }; -pub static WORD_RELA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_RELA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_RELAA_NODE), + None, + None, + 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("gation"), - dictgen::InsensitiveStr::Ascii("ibility"), - dictgen::InsensitiveStr::Ascii("ible"), - dictgen::InsensitiveStr::Ascii("ibly"), - dictgen::InsensitiveStr::Ascii("ise"), - dictgen::InsensitiveStr::Ascii("ised"), - dictgen::InsensitiveStr::Ascii("itonship"), - dictgen::InsensitiveStr::Ascii("ly"), - dictgen::InsensitiveStr::Ascii("oded"), - dictgen::InsensitiveStr::Ascii("oding"), - dictgen::InsensitiveStr::Ascii("pes"), - dictgen::InsensitiveStr::Ascii("spe"), - dictgen::InsensitiveStr::Ascii("sped"), - dictgen::InsensitiveStr::Ascii("tabe"), - dictgen::InsensitiveStr::Ascii("tation"), - dictgen::InsensitiveStr::Ascii("teds"), - dictgen::InsensitiveStr::Ascii("tiate"), - dictgen::InsensitiveStr::Ascii("tiation"), - dictgen::InsensitiveStr::Ascii("tie"), - dictgen::InsensitiveStr::Ascii("tin"), - dictgen::InsensitiveStr::Ascii("tinoship"), - dictgen::InsensitiveStr::Ascii("tionshits"), - dictgen::InsensitiveStr::Ascii("tionshp"), - dictgen::InsensitiveStr::Ascii("tionsship"), - dictgen::InsensitiveStr::Ascii("tiopnship"), - dictgen::InsensitiveStr::Ascii("tivety"), - dictgen::InsensitiveStr::Ascii("tivily"), - dictgen::InsensitiveStr::Ascii("tiviser"), - dictgen::InsensitiveStr::Ascii("tivisme"), - dictgen::InsensitiveStr::Ascii("tivitiy"), - dictgen::InsensitiveStr::Ascii("tivitly"), - dictgen::InsensitiveStr::Ascii("tiviy"), - dictgen::InsensitiveStr::Ascii("tivley"), - dictgen::InsensitiveStr::Ascii("tivly"), - dictgen::InsensitiveStr::Ascii("tivno"), - dictgen::InsensitiveStr::Ascii("tivy"), - dictgen::InsensitiveStr::Ascii("vation"), - dictgen::InsensitiveStr::Ascii("vence"), - dictgen::InsensitiveStr::Ascii("vent"), - dictgen::InsensitiveStr::Ascii("xating"), - dictgen::InsensitiveStr::Ascii("zation"), + dictgen::InsensitiveStr::Ascii("ant"), + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("ence"), + dictgen::InsensitiveStr::Ascii("ent"), ], values: &[ + &["relevant"], &["relaxation"], - &["reliability"], - &["reliable"], - &["reliably"], - &["realise"], - &["realised"], - &["relationships"], - &["really"], - &["reloaded"], - &["reloading"], - &["relapse"], - &["relapse"], - &["relapsed"], + &["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("ated"), + dictgen::InsensitiveStr::Ascii("ation"), + 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"], + &["related"], &["relaxation"], + &["related"], + &["relatedness"], &["relates"], &["retaliate"], &["retaliation"], + &["relative", "relatable"], &["relative"], + &["relatively"], + &["relative"], + &["relatively"], &["relation"], &["relationships"], &["relationships"], &["relationships"], &["relationships"], &["relationship"], + &["relative"], + &["relative", "relatively"], &["relativity"], &["relativity"], &["relatives"], @@ -20628,13 +42089,165 @@ pub static WORD_RELA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["relatively"], &["relation"], &["relativity"], - &["relaxation"], - &["relevance"], - &["relevant"], - &["relaxation"], - &["relaxation"], ], - range: 2..=9, + 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("ded"), + dictgen::InsensitiveStr::Ascii("ding"), + ], + values: &[&["reloaded"], &["reloading"]], + range: 3..=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_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 { @@ -20649,6 +42262,9 @@ pub static WORD_REK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -20656,66 +42272,150 @@ pub static WORD_REK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["renowned"], &["recommendation"], &["certifications"], + &["recursed"], + &["recursion"], + &["recursive"], ], range: 4..=11, }; -static WORD_REI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REI_CHILDREN), +static WORD_REJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_REJ_CHILDREN), value: None, }; -pub static WORD_REI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("carnation"), - dictgen::InsensitiveStr::Ascii("ceved"), - dictgen::InsensitiveStr::Ascii("gining"), - dictgen::InsensitiveStr::Ascii("gment"), - dictgen::InsensitiveStr::Ascii("gmes"), - dictgen::InsensitiveStr::Ascii("gonal"), - dictgen::InsensitiveStr::Ascii("gons"), - dictgen::InsensitiveStr::Ascii("nassance"), - dictgen::InsensitiveStr::Ascii("ncarantion"), - dictgen::InsensitiveStr::Ascii("ncatnation"), - dictgen::InsensitiveStr::Ascii("nforcemens"), - dictgen::InsensitiveStr::Ascii("nforcemnets"), - dictgen::InsensitiveStr::Ascii("nforcemnt"), - dictgen::InsensitiveStr::Ascii("nforcemnts"), - dictgen::InsensitiveStr::Ascii("nforcemt"), - dictgen::InsensitiveStr::Ascii("nfornced"), - dictgen::InsensitiveStr::Ascii("nitalise"), - dictgen::InsensitiveStr::Ascii("nitalised"), - dictgen::InsensitiveStr::Ascii("nitalises"), - dictgen::InsensitiveStr::Ascii("nitalising"), - dictgen::InsensitiveStr::Ascii("nitalization"), - dictgen::InsensitiveStr::Ascii("nitalizations"), - dictgen::InsensitiveStr::Ascii("nitalize"), - dictgen::InsensitiveStr::Ascii("nitalized"), - dictgen::InsensitiveStr::Ascii("nitalizes"), - dictgen::InsensitiveStr::Ascii("nitalizing"), - dictgen::InsensitiveStr::Ascii("nkarnation"), - dictgen::InsensitiveStr::Ascii("nstale"), - dictgen::InsensitiveStr::Ascii("nstaled"), - dictgen::InsensitiveStr::Ascii("nstaling"), - dictgen::InsensitiveStr::Ascii("nstallled"), - dictgen::InsensitiveStr::Ascii("nstallling"), - dictgen::InsensitiveStr::Ascii("nstallng"), - dictgen::InsensitiveStr::Ascii("ntarnation"), - dictgen::InsensitiveStr::Ascii("sntall"), - dictgen::InsensitiveStr::Ascii("sntalled"), - dictgen::InsensitiveStr::Ascii("sntalling"), - dictgen::InsensitiveStr::Ascii("trement"), - dictgen::InsensitiveStr::Ascii("tres"), - dictgen::InsensitiveStr::Ascii("vews"), + 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"), + ], + values: &[&["retirement"], &["retires"]], + range: 3..=6, +}; + +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_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("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("tarnation"), + dictgen::InsensitiveStr::Ascii("tepret"), + dictgen::InsensitiveStr::Ascii("tepreted"), ], values: &[ - &["reincarnation"], - &["received"], - &["reigning"], - &["regiment"], - &["regimes"], - &["regional"], - &["regions"], &["renaissance"], &["reincarnation"], &["reincarnation"], @@ -20727,6 +42427,9 @@ pub static WORD_REI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["reinforced"], &["reinitialise"], &["reinitialised"], + &["reinitialize"], + &["reinitialise"], + &["reinitialised"], &["reinitialises"], &["reinitialising"], &["reinitialization"], @@ -20735,6 +42438,8 @@ pub static WORD_REI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["reinitialized"], &["reinitializes"], &["reinitializing"], + &["reinitialize"], + &["reinitialized"], &["reincarnation"], &["reinstalled"], &["reinstalled"], @@ -20743,14 +42448,96 @@ pub static WORD_REI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["reinstalling"], &["reinstalling"], &["reincarnation"], - &["reinstall"], - &["reinstalled"], - &["reinstalling"], - &["retirement"], - &["retires"], - &["reviews"], + &["reinterpret"], + &["reinterpreted"], ], - range: 4..=13, + range: 5..=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("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"), + ], + values: &[ + &["reimplement"], + &["reimplementation"], + &["reimplementations"], + &["reimplemented"], + &["reimplements"], + &["reimplement"], + &["reimplementing"], + &["reimplement"], + &["reimplement"], + &["reimplementation"], + &["reimplemented"], + &["reimplementing"], + &["reimplements"], + ], + range: 6..=12, +}; + +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("ining"), + dictgen::InsensitiveStr::Ascii("ment"), + dictgen::InsensitiveStr::Ascii("mes"), + 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: &[ + &["reigning"], + &["regiment"], + &["regimes"], + &["regional"], + &["regions"], + &["register"], + &["registered"], + &["registering"], + &["registers"], + &["registration"], + ], + range: 3..=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 { @@ -20766,6 +42553,7 @@ pub static WORD_REH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("abilitatin"), dictgen::InsensitiveStr::Ascii("abilitaton"), dictgen::InsensitiveStr::Ascii("ersal"), + dictgen::InsensitiveStr::Ascii("ersing"), dictgen::InsensitiveStr::Ascii("toric"), dictgen::InsensitiveStr::Ascii("torical"), ], @@ -20776,6 +42564,7 @@ pub static WORD_REH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["rehabilitation"], &["rehabilitation"], &["rehearsal"], + &["rehearsing"], &["rhetoric"], &["rhetorical"], ], @@ -20817,73 +42606,155 @@ static WORD_REG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] ]; static WORD_REGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_REGU_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_REGU_CHILDREN), value: None, }; -pub static WORD_REGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_REGU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_REGUA_NODE), + None, + None, + None, + None, + None, + None, + None, + None, + 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("alrly"), - dictgen::InsensitiveStr::Ascii("alrs"), - dictgen::InsensitiveStr::Ascii("alte"), - dictgen::InsensitiveStr::Ascii("alting"), - dictgen::InsensitiveStr::Ascii("altion"), - dictgen::InsensitiveStr::Ascii("altions"), - dictgen::InsensitiveStr::Ascii("altor"), - dictgen::InsensitiveStr::Ascii("altors"), - dictgen::InsensitiveStr::Ascii("arly"), - dictgen::InsensitiveStr::Ascii("lacion"), - dictgen::InsensitiveStr::Ascii("lae"), - dictgen::InsensitiveStr::Ascii("laion"), - dictgen::InsensitiveStr::Ascii("lalry"), - dictgen::InsensitiveStr::Ascii("lament"), - dictgen::InsensitiveStr::Ascii("laotrs"), - dictgen::InsensitiveStr::Ascii("lares"), - dictgen::InsensitiveStr::Ascii("larily"), - dictgen::InsensitiveStr::Ascii("laring"), - dictgen::InsensitiveStr::Ascii("laris"), - dictgen::InsensitiveStr::Ascii("larlas"), - dictgen::InsensitiveStr::Ascii("larlos"), - dictgen::InsensitiveStr::Ascii("lary"), - dictgen::InsensitiveStr::Ascii("las"), - dictgen::InsensitiveStr::Ascii("laters"), - dictgen::InsensitiveStr::Ascii("latin"), - dictgen::InsensitiveStr::Ascii("lationg"), - dictgen::InsensitiveStr::Ascii("latiors"), - dictgen::InsensitiveStr::Ascii("latios"), - dictgen::InsensitiveStr::Ascii("latons"), - dictgen::InsensitiveStr::Ascii("latorias"), - dictgen::InsensitiveStr::Ascii("latories"), - dictgen::InsensitiveStr::Ascii("latorios"), - dictgen::InsensitiveStr::Ascii("latr"), - dictgen::InsensitiveStr::Ascii("lats"), - dictgen::InsensitiveStr::Ascii("lsr"), - dictgen::InsensitiveStr::Ascii("rally"), + dictgen::InsensitiveStr::Ascii("ally"), + dictgen::InsensitiveStr::Ascii("larly"), + ], + values: &[&["regularly"], &["regularly"]], + range: 4..=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: &[ - &["regularly"], - &["regulars"], - &["regulate"], - &["regulating"], - &["regulations"], - &["regulations"], - &["regulator"], - &["regulators"], - &["regularly"], &["regulation"], &["regulate"], + &["regular"], &["regulation"], &["regularly"], &["regulate"], + &["regulation"], + &["regulations"], &["regulators"], + &["regulatory"], &["regulars"], &["regularly"], &["regulating"], - &["regulars"], - &["regulars"], - &["regulars"], &["regularly"], &["regulars"], + &["regulars"], + &["regularisation"], + &["regularise"], + &["regularised"], + &["regulariser"], + &["regularises"], + &["regularising"], + &["regularization"], + &["regularize"], + &["regularized"], + &["regularizer"], + &["regularizes"], + &["regularizing"], + &["regularly"], + &["regulars"], + &["regularly", "regular"], + &["regulars"], &["regulators"], &["regulations"], &["regulating"], @@ -20895,10 +42766,68 @@ pub static WORD_REGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["regulators"], &["regulator"], &["regulators"], + &["regular"], + &["regular"], + &["regular"], &["regulars"], - &["regularly"], + &["regulator"], + &["regulators"], + &["regulatory"], ], - range: 3..=8, + range: 1..=11, +}; + +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 { @@ -20907,9 +42836,35 @@ static WORD_REGS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_REGS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("itry")], - values: &[&["registry"]], - range: 4..=4, + 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("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"], + &["registry"], + &["register"], + &["registered"], + &["registering"], + &["registers"], + &["registry"], + ], + range: 3..=7, }; static WORD_REGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20921,6 +42876,7 @@ pub static WORD_REGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("esas"), dictgen::InsensitiveStr::Ascii("eses"), + dictgen::InsensitiveStr::Ascii("esion"), dictgen::InsensitiveStr::Ascii("esives"), dictgen::InsensitiveStr::Ascii("esos"), dictgen::InsensitiveStr::Ascii("esse"), @@ -20936,6 +42892,7 @@ pub static WORD_REGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["regress"], &["regress"], + &["regression"], &["regressive"], &["regress"], &["regressive"], @@ -20957,9 +42914,13 @@ static WORD_REGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_REGO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("cnition")], - values: &[&["recognition"]], - range: 7..=7, + keys: &[ + dictgen::InsensitiveStr::Ascii("cnition"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("rded"), + ], + values: &[&["recognition"], &["region"], &["recorded"]], + range: 1..=7, }; static WORD_REGL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -20980,44 +42941,90 @@ static WORD_REGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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("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("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("straration"), dictgen::InsensitiveStr::Ascii("strating"), dictgen::InsensitiveStr::Ascii("strato"), + dictgen::InsensitiveStr::Ascii("stred"), + dictgen::InsensitiveStr::Ascii("strer"), + dictgen::InsensitiveStr::Ascii("string"), + dictgen::InsensitiveStr::Ascii("strs"), dictgen::InsensitiveStr::Ascii("sty"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("tered"), + dictgen::InsensitiveStr::Ascii("tering"), + dictgen::InsensitiveStr::Ascii("ters"), ], values: &[ + &["registered"], &["regimes"], &["regiment"], &["regional"], &["regions"], - &["registry"], - &["registration"], - &["registered"], - &["registered"], - &["registers"], - &["registers"], - &["registers"], - &["registered"], - &["registry"], - &["registration"], - &["registration"], + &["register"], &["registration"], &["registry"], + &["register"], + &["registration"], + &["register"], + &["registered"], + &["registering"], + &["registration"], + &["registered", "registers"], + &["registers"], + &["registered"], + &["registers"], + &["registered"], + &["registers"], + &["registered"], + &["registered"], + &["registry"], + &["registers"], + &["registering"], + &["registers"], + &["registration"], + &["registration"], + &["registration"], + &["registration"], + &["registration"], + &["registered"], + &["register"], + &["registering"], + &["registers"], + &["registry"], + &["register"], + &["registered"], + &["registering"], + &["registers"], ], - range: 3..=8, + range: 2..=10, }; static WORD_REGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21027,28 +43034,50 @@ static WORD_REGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("stered"), dictgen::InsensitiveStr::Ascii("stration"), ], values: &[ + &["register"], + &["registered"], + &["registration"], &["renegade"], &["regenerate"], + &["regenerated"], &["regeneration"], &["regeneration"], &["regeneration"], &["regeneration"], &["regenerate"], + &["regenerated"], + &["regenerated"], + &["regenerating"], + &["regeneration"], + &["regenerative"], &["regrets"], + &["regression"], + &["registered"], &["registration"], ], - range: 3..=8, + range: 3..=9, }; static WORD_REGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21057,9 +43086,35 @@ static WORD_REGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_REGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rdes")], - values: &[&["regards"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("lar"), + dictgen::InsensitiveStr::Ascii("lars"), + dictgen::InsensitiveStr::Ascii("rdes"), + dictgen::InsensitiveStr::Ascii("rdles"), + dictgen::InsensitiveStr::Ascii("rdlesss"), + 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"], + &["regarding"], + &["regardless"], + &["regardless"], + &["regard"], + &["regarded"], + &["regarding"], + &["regardless"], + ], + range: 2..=7, }; static WORD_REF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21068,9 +43123,9 @@ static WORD_REF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_REF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_REFA_NODE), None, - None, - None, + Some(&WORD_REFC_NODE), None, Some(&WORD_REFE_NODE), Some(&WORD_REFF_NODE), @@ -21106,15 +43161,19 @@ pub static WORD_REFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: 3..=7, + range: 2..=7, }; static WORD_REFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21124,10 +43183,18 @@ static WORD_REFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -21140,16 +43207,26 @@ pub static WORD_REFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("igerar"), dictgen::InsensitiveStr::Ascii("igerater"), dictgen::InsensitiveStr::Ascii("igirator"), + dictgen::InsensitiveStr::Ascii("omatting"), dictgen::InsensitiveStr::Ascii("omed"), dictgen::InsensitiveStr::Ascii("omist"), 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"], @@ -21162,12 +43239,14 @@ pub static WORD_REFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["refrigerator"], &["refrigerator"], &["refrigerator"], + &["refomatting"], &["reformed"], &["reformist"], &["reforms"], + &["reformatting"], &["refurbished"], ], - range: 3..=10, + range: 2..=10, }; static WORD_REFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21177,11 +43256,22 @@ static WORD_REFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_REFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cuss"), + dictgen::InsensitiveStr::Ascii("cussed"), + dictgen::InsensitiveStr::Ascii("rmating"), + dictgen::InsensitiveStr::Ascii("rmattd"), dictgen::InsensitiveStr::Ascii("rmerad"), dictgen::InsensitiveStr::Ascii("rmes"), ], - values: &[&["reformed"], &["reforms"]], - range: 4..=6, + values: &[ + &["refocus"], + &["refocused"], + &["reformatting"], + &["reformatted"], + &["reformed"], + &["reforms"], + ], + range: 4..=7, }; static WORD_REFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21224,9 +43314,19 @@ pub static WORD_REFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["refrigerator"]], + values: &[ + &["refills"], + &["refills"], + &["refinement"], + &["refinement"], + &["refinement"], + &["refrigerator"], + ], range: 4..=8, }; @@ -21239,77 +43339,401 @@ pub static WORD_REFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["referring"]], - range: 4..=6, + 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::Flat(&WORD_REFE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_REFE_CHILDREN), value: None, }; -pub static WORD_REFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ct"), - dictgen::InsensitiveStr::Ascii("dendum"), - dictgen::InsensitiveStr::Ascii("eres"), - dictgen::InsensitiveStr::Ascii("lct"), - dictgen::InsensitiveStr::Ascii("lcted"), - dictgen::InsensitiveStr::Ascii("lcting"), - dictgen::InsensitiveStr::Ascii("lction"), - dictgen::InsensitiveStr::Ascii("lctions"), - dictgen::InsensitiveStr::Ascii("lctive"), - dictgen::InsensitiveStr::Ascii("lcts"), - dictgen::InsensitiveStr::Ascii("lxes"), - dictgen::InsensitiveStr::Ascii("ral"), - dictgen::InsensitiveStr::Ascii("rances"), - dictgen::InsensitiveStr::Ascii("rancing"), - dictgen::InsensitiveStr::Ascii("randum"), - dictgen::InsensitiveStr::Ascii("reces"), - dictgen::InsensitiveStr::Ascii("red"), - dictgen::InsensitiveStr::Ascii("rede"), - dictgen::InsensitiveStr::Ascii("reees"), - dictgen::InsensitiveStr::Ascii("reers"), - dictgen::InsensitiveStr::Ascii("remce"), - dictgen::InsensitiveStr::Ascii("remces"), - dictgen::InsensitiveStr::Ascii("remdum"), - dictgen::InsensitiveStr::Ascii("renceing"), - dictgen::InsensitiveStr::Ascii("rencs"), - dictgen::InsensitiveStr::Ascii("rendim"), - dictgen::InsensitiveStr::Ascii("rendom"), - dictgen::InsensitiveStr::Ascii("rene"), - dictgen::InsensitiveStr::Ascii("renece"), - dictgen::InsensitiveStr::Ascii("reneced"), - dictgen::InsensitiveStr::Ascii("reneces"), - dictgen::InsensitiveStr::Ascii("rening"), - dictgen::InsensitiveStr::Ascii("rens"), - dictgen::InsensitiveStr::Ascii("rense"), - dictgen::InsensitiveStr::Ascii("renses"), - dictgen::InsensitiveStr::Ascii("rentes"), - dictgen::InsensitiveStr::Ascii("rere"), - dictgen::InsensitiveStr::Ascii("riang"), - dictgen::InsensitiveStr::Ascii("rig"), - dictgen::InsensitiveStr::Ascii("rign"), - dictgen::InsensitiveStr::Ascii("rincing"), - dictgen::InsensitiveStr::Ascii("ring"), - dictgen::InsensitiveStr::Ascii("rinng"), - dictgen::InsensitiveStr::Ascii("rnce"), - dictgen::InsensitiveStr::Ascii("rnces"), - dictgen::InsensitiveStr::Ascii("rnece"), - dictgen::InsensitiveStr::Ascii("rneces"), - dictgen::InsensitiveStr::Ascii("rrence"), - dictgen::InsensitiveStr::Ascii("rrences"), - dictgen::InsensitiveStr::Ascii("rrs"), - dictgen::InsensitiveStr::Ascii("rshed"), - dictgen::InsensitiveStr::Ascii("rsher"), - dictgen::InsensitiveStr::Ascii("rundum"), + dictgen::InsensitiveStr::Ascii("h"), + dictgen::InsensitiveStr::Ascii("hed"), + dictgen::InsensitiveStr::Ascii("hes"), + dictgen::InsensitiveStr::Ascii("hing"), ], values: &[ - &["reflect"], - &["referendum"], + &["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("s"), + ], + values: &[ + &["reference"], + &["referenced"], + &["references"], + &["referencing"], + &["referrers"], + &["refers"], + &["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("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("nence"), + dictgen::InsensitiveStr::Ascii("nenced"), + dictgen::InsensitiveStr::Ascii("nences"), + dictgen::InsensitiveStr::Ascii("nes"), + dictgen::InsensitiveStr::Ascii("ning"), + 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"], + &["referencing"], + &["referential"], + &["referentially"], + &["references"], + &["referenced"], + &["referendum"], + &["referendum"], + &["referee", "reference"], + &["reference"], + &["referenced"], + &["references"], + &["reference"], + &["referenced"], + &["references"], + &["references"], + &["referencing"], + &["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("nces"), + dictgen::InsensitiveStr::Ascii("ncing"), + dictgen::InsensitiveStr::Ascii("ndum"), + dictgen::InsensitiveStr::Ascii("nt"), + ], + values: &[ + &["referral"], + &["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"], @@ -21317,51 +43741,106 @@ pub static WORD_REFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["reflections"], &["reflective"], &["reflects"], + &["reflects"], &["reflexes"], - &["referral"], - &["references"], - &["referencing"], - &["referendum"], - &["references"], - &["referred"], - &["referee"], - &["referees"], - &["referees"], - &["reference"], - &["references"], - &["referendum"], - &["referencing"], - &["references"], - &["referendum"], - &["referendum"], - &["referee"], - &["reference"], - &["referenced"], - &["references"], - &["referencing"], - &["references"], - &["references"], - &["referees"], - &["references"], - &["referee"], - &["referring"], - &["referring"], - &["referring"], - &["referencing"], - &["referring"], - &["referring"], - &["reference"], - &["references"], - &["reference"], - &["references"], - &["reference"], - &["references"], - &["refers"], - &["refreshed"], - &["refresher"], - &["referendum"], ], - range: 2..=8, + 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 { @@ -21373,95 +43852,308 @@ pub static WORD_REE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("demed"), dictgen::InsensitiveStr::Ascii("deming"), + dictgen::InsensitiveStr::Ascii("lation"), + dictgen::InsensitiveStr::Ascii("lease"), + dictgen::InsensitiveStr::Ascii("name"), dictgen::InsensitiveStr::Ascii("ncarnation"), + dictgen::InsensitiveStr::Ascii("srved"), + dictgen::InsensitiveStr::Ascii("sult"), 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: &[ &["redeemed"], &["redeeming"], + &["relation"], + &["release"], + &["rename"], &["reincarnation"], + &["reserved"], + &["result"], &["reevaluate"], &["reevaluate"], &["reevaluate"], &["reevaluate"], + &["reevaluate"], + &["reevaluating"], ], - range: 5..=10, + range: 4..=10, }; static WORD_RED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RED_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_RED_CHILDREN), value: None, }; -pub static WORD_RED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("eemd"), - dictgen::InsensitiveStr::Ascii("eemeed"), - dictgen::InsensitiveStr::Ascii("efinied"), - dictgen::InsensitiveStr::Ascii("efinine"), - dictgen::InsensitiveStr::Ascii("eisgn"), - dictgen::InsensitiveStr::Ascii("emeed"), - dictgen::InsensitiveStr::Ascii("emtpion"), - dictgen::InsensitiveStr::Ascii("epmtion"), - dictgen::InsensitiveStr::Ascii("esgin"), - dictgen::InsensitiveStr::Ascii("esiging"), - dictgen::InsensitiveStr::Ascii("esing"), - dictgen::InsensitiveStr::Ascii("iculous"), - dictgen::InsensitiveStr::Ascii("istirbution"), - dictgen::InsensitiveStr::Ascii("istribucion"), - dictgen::InsensitiveStr::Ascii("istribuito"), - dictgen::InsensitiveStr::Ascii("istributin"), - dictgen::InsensitiveStr::Ascii("istributivo"), - dictgen::InsensitiveStr::Ascii("istrubition"), - dictgen::InsensitiveStr::Ascii("meption"), - dictgen::InsensitiveStr::Ascii("neckers"), - dictgen::InsensitiveStr::Ascii("neckese"), - dictgen::InsensitiveStr::Ascii("neckest"), - dictgen::InsensitiveStr::Ascii("ners"), - dictgen::InsensitiveStr::Ascii("uncancy"), - dictgen::InsensitiveStr::Ascii("undantcy"), - dictgen::InsensitiveStr::Ascii("undany"), - dictgen::InsensitiveStr::Ascii("undency"), - dictgen::InsensitiveStr::Ascii("undent"), - dictgen::InsensitiveStr::Ascii("undnacy"), - dictgen::InsensitiveStr::Ascii("unduncy"), + dictgen::InsensitiveStr::Ascii("dancy"), + dictgen::InsensitiveStr::Ascii("dant"), + dictgen::InsensitiveStr::Ascii("nancy"), + dictgen::InsensitiveStr::Ascii("nant"), + dictgen::InsensitiveStr::Ascii("ncancy"), + dictgen::InsensitiveStr::Ascii("ndacy"), + 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: &[ - &["redeemed"], - &["redeemed"], - &["redefine"], - &["redefine"], - &["redesign"], - &["redeemed"], - &["redemption"], - &["redemption"], - &["redesign"], - &["redesign"], - &["redesign"], - &["ridiculous"], - &["redistribution"], - &["redistribution"], - &["redistribution"], - &["redistribution"], - &["redistribution"], - &["redistribution"], - &["redemption"], - &["rednecks"], - &["rednecks"], - &["rednecks"], - &["renders"], + &["redundancy"], + &["redundant"], + &["redundancy"], + &["redundant"], &["redundancy"], &["redundancy"], &["redundancy"], &["redundancy"], &["redundant"], &["redundancy"], + &["redundant"], &["redundancy"], + &["redundancy"], + &["redundancy"], + &["redundant"], + &["reduce", "reuse"], ], - range: 4..=11, + 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("finition"), + dictgen::InsensitiveStr::Ascii("fintion"), + dictgen::InsensitiveStr::Ascii("fintions"), + dictgen::InsensitiveStr::Ascii("rcet"), + 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("stributin"), + dictgen::InsensitiveStr::Ascii("stributivo"), + dictgen::InsensitiveStr::Ascii("strubition"), + ], + values: &[ + &["redirect"], + &["ridiculous"], + &["residual"], + &["redefinition"], + &["redefinition"], + &["redefinitions"], + &["redirect"], + &["redirected"], + &["redirection"], + &["redesign"], + &["redistribute"], + &["redistributed"], + &["redistributes"], + &["redistributing"], + &["redistribution"], + &["redistribution"], + &["redistribution"], + &["redistribution"], + &["redistribution"], + &["redistribution"], + ], + range: 2..=10, +}; + +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("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"], + &["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("ndant")], + values: &[&["redundant"]], + range: 5..=5, }; static WORD_REC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21483,7 +44175,7 @@ static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_RECL_NODE), None, - None, + Some(&WORD_RECN_NODE), Some(&WORD_RECO_NODE), Some(&WORD_RECP_NODE), Some(&WORD_RECQ_NODE), @@ -21494,10 +44186,35 @@ static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, 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, @@ -21505,32 +44222,58 @@ static WORD_RECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ring"), 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("rsivelly"), + dictgen::InsensitiveStr::Ascii("rsivion"), + dictgen::InsensitiveStr::Ascii("rsivley"), dictgen::InsensitiveStr::Ascii("rsivly"), + dictgen::InsensitiveStr::Ascii("sion"), + dictgen::InsensitiveStr::Ascii("sive"), + dictgen::InsensitiveStr::Ascii("sively"), dictgen::InsensitiveStr::Ascii("srion"), + dictgen::InsensitiveStr::Ascii("srive"), + dictgen::InsensitiveStr::Ascii("srsive"), + dictgen::InsensitiveStr::Ascii("stion"), ], values: &[ + &["reduce"], &["recruiting"], + &["recursively"], &["recurring"], &["recursion"], + &["recursively"], &["recruited"], &["recruiter"], &["recruiters"], &["recruitment"], &["recruits"], + &["recursively"], &["recurrence"], &["recursively"], &["recursion"], + &["recursively"], + &["recursively"], + &["recursion", "reclusion"], + &["recursive", "reclusive"], + &["recursively", "reclusively"], + &["recursion"], + &["recursive"], + &["recursive"], + &["recursion"], ], - range: 4..=7, + range: 2..=8, }; static WORD_RECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21542,6 +44285,7 @@ pub static WORD_RECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -21551,10 +44295,12 @@ pub static WORD_RECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("anlge"), dictgen::InsensitiveStr::Ascii("engular"), dictgen::InsensitiveStr::Ascii("ifiy"), + dictgen::InsensitiveStr::Ascii("iinear"), ], values: &[ &["rectangle"], &["rectangle"], + &["rectangles"], &["rectangular"], &["rectangular"], &["rectangular"], @@ -21564,6 +44310,7 @@ pub static WORD_RECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["rectangle"], &["rectangular"], &["rectify"], + &["rectilinear"], ], range: 4..=9, }; @@ -21578,15 +44325,21 @@ pub static WORD_RECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("iational"), dictgen::InsensitiveStr::Ascii("od"), + dictgen::InsensitiveStr::Ascii("ods"), 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"), @@ -21596,15 +44349,21 @@ pub static WORD_RECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["recreational"], &["recreation"], &["recreational"], + &["recreation"], &["recreate"], &["recreate"], &["recreational"], &["recreation"], &["recreational"], &["record"], + &["records"], &["recruits"], &["recruits"], + &["recursively"], &["recursion"], + &["recursive"], + &["recursively"], + &["recursively"], &["recruited"], &["recruiter"], &["recruiters"], @@ -21654,9 +44413,9 @@ static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_RECOC_NODE), + Some(&WORD_RECOD_NODE), None, - None, - None, + Some(&WORD_RECOF_NODE), Some(&WORD_RECOG_NODE), None, None, @@ -21671,7 +44430,7 @@ static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_RECOR_NODE), None, None, - None, + Some(&WORD_RECOU_NODE), Some(&WORD_RECOV_NODE), None, None, @@ -21694,6 +44453,27 @@ pub static WORD_RECOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di range: 2..=4, }; +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, @@ -21706,6 +44486,8 @@ pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("darme"), dictgen::InsensitiveStr::Ascii("darse"), dictgen::InsensitiveStr::Ascii("darte"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("iding"), dictgen::InsensitiveStr::Ascii("re"), ], values: &[ @@ -21714,52 +44496,168 @@ pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["recorder"], &["recorder"], &["recorder"], + &["recorded"], + &["recording"], &["recorder"], ], range: 2..=5, }; static WORD_RECON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_RECON_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_RECON_CHILDREN), value: None, }; -pub static WORD_RECON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aissance"), - dictgen::InsensitiveStr::Ascii("cider"), - dictgen::InsensitiveStr::Ascii("cilation"), - dictgen::InsensitiveStr::Ascii("cille"), - dictgen::InsensitiveStr::Ascii("cilled"), - dictgen::InsensitiveStr::Ascii("enct"), - dictgen::InsensitiveStr::Ascii("gise"), - dictgen::InsensitiveStr::Ascii("gised"), - dictgen::InsensitiveStr::Ascii("gition"), - dictgen::InsensitiveStr::Ascii("gizable"), - dictgen::InsensitiveStr::Ascii("gize"), - dictgen::InsensitiveStr::Ascii("gized"), - dictgen::InsensitiveStr::Ascii("gizes"), - dictgen::InsensitiveStr::Ascii("gizing"), - dictgen::InsensitiveStr::Ascii("icle"), - dictgen::InsensitiveStr::Ascii("isder"), - dictgen::InsensitiveStr::Ascii("ized"), - dictgen::InsensitiveStr::Ascii("naisance"), - dictgen::InsensitiveStr::Ascii("naissence"), - dictgen::InsensitiveStr::Ascii("net"), - dictgen::InsensitiveStr::Ascii("sidder"), - dictgen::InsensitiveStr::Ascii("siled"), - dictgen::InsensitiveStr::Ascii("struccion"), - dictgen::InsensitiveStr::Ascii("strucion"), - dictgen::InsensitiveStr::Ascii("sturction"), - dictgen::InsensitiveStr::Ascii("tructed"), + 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: &[ + &["reconstructed"], + &["reconstructing"], + &["reconstruction"], + &["reconstructions"], + &["reconstructor"], + &["reconstructors"], + &["reconstructs"], + ], + range: 5..=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: &[ - &["reconnaissance"], &["reconsider"], - &["reconciliation"], + &["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("et"), + ], + values: &[&["reconnaissance"], &["reconnaissance"], &["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"], - &["reconcile"], - &["reconnect"], + &["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"], @@ -21768,20 +44666,151 @@ pub static WORD_RECON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["recognized"], &["recognizes"], &["recognizing"], - &["reconcile"], - &["reconsider"], - &["recognized"], - &["reconnaissance"], - &["reconnaissance"], - &["reconnect"], - &["reconsider"], - &["reconsider"], - &["reconstruction"], - &["reconstruction"], - &["reconstruction"], - &["reconstructed"], + &["recognises"], + &["recognizes"], ], - range: 3..=9, + 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")], + values: &[&["reconnaissance"]], + range: 7..=7, }; static WORD_RECOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21792,18 +44821,33 @@ static WORD_RECOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_RECOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("end"), + dictgen::InsensitiveStr::Ascii("endations"), 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"), @@ -21814,39 +44858,90 @@ pub static WORD_RECOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], + &["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"], - &["recommend"], + &["recommends"], + &["recommend", "recommended"], &["recommended"], &["recommends"], &["recommends"], &["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: 3..=10, + range: 2..=10, }; static WORD_RECOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21873,11 +44968,17 @@ pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), ], @@ -21888,15 +44989,43 @@ pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["recognized"], &["recognise"], &["recognize"], + &["recognized"], + &["recognizes"], + &["recognizing"], + &["recognised"], &["recognizes"], &["recognizing"], &["recognizes"], + &["recognise"], &["recognition"], &["recognition"], &["recognizable"], + &["recognizable"], &["recognised"], ], - range: 3..=7, + 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 { @@ -21910,6 +45039,20 @@ pub static WORD_RECOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di range: 5..=5, }; +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, @@ -21917,13 +45060,20 @@ static WORD_RECL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["reclaim"], &["reclaim"], &["reluctant"], &["reluctantly"]], - range: 3..=7, + values: &[ + &["reclamation"], + &["reclaim"], + &["reclaim"], + &["reluctant"], + &["reluctantly"], + ], + range: 3..=8, }; static WORD_RECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -21947,12 +45097,15 @@ pub static WORD_RECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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"), @@ -21960,10 +45113,15 @@ pub static WORD_RECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("vership"), + dictgen::InsensitiveStr::Ascii("ves"), + dictgen::InsensitiveStr::Ascii("ving"), ], values: &[ &["reside"], @@ -21980,12 +45138,15 @@ pub static WORD_RECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["receivers"], &["receives"], &["receiving"], + &["receives"], &["recipes"], &["recipients"], &["recipes"], &["recipient"], &["recipients"], + &["recipe"], &["recipients"], + &["recipes"], &["reciprocate"], &["reciprocate"], &["reciprocate"], @@ -21993,10 +45154,15 @@ pub static WORD_RECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["reciprocate"], &["reciprocate"], &["reciprocate"], + &["reciprocal"], + &["reciprocals"], &["reciprocate"], &["rectify"], + &["receive"], &["received"], &["receivership"], + &["receives"], + &["receiving"], ], range: 2..=8, }; @@ -22008,11 +45174,20 @@ static WORD_RECH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["rechargeable"], &["reached"]], - range: 2..=7, + values: &[ + &["reachable"], + &["rechargeable"], + &["reachability"], + &["reached"], + &["recheck"], + ], + range: 2..=8, }; static WORD_RECG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22053,10 +45228,25 @@ pub static WORD_RECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("eded"), dictgen::InsensitiveStr::Ascii("eding"), + 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("iveing"), + dictgen::InsensitiveStr::Ascii("iviing"), + dictgen::InsensitiveStr::Ascii("net"), + dictgen::InsensitiveStr::Ascii("nlty"), + dictgen::InsensitiveStr::Ascii("nly"), 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("ptie"), dictgen::InsensitiveStr::Ascii("ptionest"), @@ -22066,15 +45256,36 @@ pub static WORD_RECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("vies"), dictgen::InsensitiveStr::Ascii("ving"), ], values: &[ &["receded"], &["receding"], + &["received"], + &["receive"], + &["received"], + &["receives"], + &["receiving"], + &["recipient"], + &["recipients"], &["receipts"], + &["reception"], + &["receiving"], + &["receiving"], + &["recent"], + &["recently"], + &["recently"], &["receptionist"], &["recipient"], &["recipients"], + &["reception"], + &["recipe", "receipt"], &["receipts"], &["receptive"], &["receptionist"], @@ -22084,9 +45295,15 @@ pub static WORD_RECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["receptors"], &["receptors"], &["receptors"], + &["receive"], + &["received"], + &["receives"], + &["receive"], + &["received"], + &["receives"], &["receiving"], ], - range: 3..=9, + range: 2..=9, }; static WORD_RECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22101,9 +45318,44 @@ pub static WORD_RECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("uring"), + dictgen::InsensitiveStr::Ascii("ursive"), + dictgen::InsensitiveStr::Ascii("ursively"), ], values: &[ &["recommend"], @@ -22111,11 +45363,46 @@ pub static WORD_RECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["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"], &["recurring"], + &["recursive"], + &["recursively"], ], - range: 5..=11, + range: 4..=12, }; static WORD_RECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22125,11 +45412,25 @@ static WORD_RECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_RECA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("hed"), + dictgen::InsensitiveStr::Ascii("lcuated"), + dictgen::InsensitiveStr::Ascii("lcution"), dictgen::InsensitiveStr::Ascii("lim"), dictgen::InsensitiveStr::Ascii("llection"), + dictgen::InsensitiveStr::Ascii("lulate"), + dictgen::InsensitiveStr::Ascii("lulation"), dictgen::InsensitiveStr::Ascii("tions"), ], - values: &[&["reclaim"], &["recollection"], &["creations"]], + values: &[ + &["reached"], + &["recalculated"], + &["recalculation"], + &["reclaim"], + &["recollection"], + &["recalculate"], + &["recalculation"], + &["creations"], + ], range: 3..=8, }; @@ -22144,15 +45445,27 @@ pub static WORD_REB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -22163,21 +45476,33 @@ pub static WORD_REB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["rebellious"], &["rebuilding"], &["rebellions"], + &["reboot"], &["rebounding"], &["rebounds"], &["rebound"], &["rebounding"], &["rebounds"], &["rebuilding"], - &["rebuilding"], + &["rebuild", "rebuilt"], &["rebuilt"], &["rebuilding"], &["rebuilt"], + &["rebuilt"], + &["rebuilds"], + &["rebuilds", "rebuilt", "rebuild"], + &["rebuilt"], + &["rebuild"], + &["rebuilding"], + &["rebuilds"], + &["rebuild"], + &["rebuilding"], + &["rebuilds"], + &["rebuilt"], &["republic"], &["republican"], &["republicans"], ], - range: 4..=8, + range: 3..=8, }; static WORD_REA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22186,34 +45511,45 @@ static WORD_REA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_REA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_REAA_NODE), None, Some(&WORD_REAC_NODE), Some(&WORD_READ_NODE), - None, + Some(&WORD_REAE_NODE), None, Some(&WORD_REAG_NODE), None, + Some(&WORD_REAI_NODE), None, - None, - None, + Some(&WORD_REAK_NODE), Some(&WORD_REAL_NODE), Some(&WORD_REAM_NODE), - None, - None, + Some(&WORD_REAN_NODE), + Some(&WORD_REAO_NODE), Some(&WORD_REAP_NODE), - None, - None, + Some(&WORD_REAQ_NODE), + Some(&WORD_REAR_NODE), Some(&WORD_REAS_NODE), Some(&WORD_REAT_NODE), None, Some(&WORD_REAV_NODE), None, 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, @@ -22234,9 +45570,13 @@ static WORD_REAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_REAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iler")], - values: &[&["retailer"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("iler"), + dictgen::InsensitiveStr::Ascii("ime"), + dictgen::InsensitiveStr::Ascii("tachement"), + ], + values: &[&["retailer"], &["realtime"], &["reattachment"]], + range: 3..=9, }; static WORD_REAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22247,33 +45587,165 @@ static WORD_REAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("socition"), + dictgen::InsensitiveStr::Ascii("ssign"), dictgen::InsensitiveStr::Ascii("sureing"), dictgen::InsensitiveStr::Ascii("surring"), + dictgen::InsensitiveStr::Ascii("y"), ], values: &[ &["research"], + &["researcher"], + &["researchers"], &["research"], &["researched"], &["researcher"], &["researchers"], &["researching"], + &["reasonable"], + &["reasonable"], &["reasonably"], &["reasonably"], &["reasonably"], &["reasonably"], + &["reasonably"], + &["reasonable"], + &["reasonably"], + &["reasonable"], + &["reasonably"], + &["reassociation"], + &["reassign"], &["reassuring"], &["reassuring"], + &["ready", "easy"], ], - range: 4..=8, + 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 { @@ -22289,6 +45761,10 @@ pub static WORD_REAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: &[ &["repaired"], @@ -22297,10 +45773,51 @@ pub static WORD_REAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["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, @@ -22308,12 +45825,20 @@ static WORD_REAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_REAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("de"), dictgen::InsensitiveStr::Ascii("ined"), dictgen::InsensitiveStr::Ascii("ining"), dictgen::InsensitiveStr::Ascii("ins"), + dictgen::InsensitiveStr::Ascii("pping"), ], - values: &[&["remained"], &["remaining"], &["remains"]], - range: 3..=5, + values: &[ + &["readme"], + &["remained"], + &["remaining"], + &["remains"], + &["remapping", "revamping"], + ], + range: 2..=5, }; static WORD_REAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22323,6 +45848,10 @@ static WORD_REAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -22337,7 +45866,26 @@ pub static WORD_REAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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"), @@ -22345,6 +45893,7 @@ pub static WORD_REAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("sim"), dictgen::InsensitiveStr::Ascii("sitic"), dictgen::InsensitiveStr::Ascii("table"), + dictgen::InsensitiveStr::Ascii("ted"), dictgen::InsensitiveStr::Ascii("tes"), dictgen::InsensitiveStr::Ascii("tion"), dictgen::InsensitiveStr::Ascii("tions"), @@ -22357,6 +45906,10 @@ pub static WORD_REAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("yl"), ], values: &[ + &["release"], + &["released"], + &["releases"], + &["reliable"], &["reliability"], &["reliable"], &["reliably"], @@ -22371,7 +45924,26 @@ pub static WORD_REAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["realistically"], &["realistically"], &["realistic"], + &["realtime"], &["relatively"], + &["really"], + &["real", "really"], + &["really"], + &["realize"], + &["really"], + &["reallocate"], + &["reallocates"], + &["reallocating"], + &["reallocating"], + &["reallocation"], + &["reallocations"], + &["reallocate"], + &["reallocates"], + &["reallocating"], + &["reallocation"], + &["reallocations"], + &["reallocation"], + &["reallocations"], &["reloaded"], &["reloading"], &["realise"], @@ -22379,18 +45951,44 @@ pub static WORD_REAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["realism"], &["realistic"], &["relatable"], + &["related"], &["relates"], - &["relation"], - &["relations"], + &["relation", "reaction"], + &["relations", "reactions"], &["relationships"], - &["relative"], + &["relative", "reactive"], &["relatively"], &["relatives"], &["relativity"], &["really"], &["really"], ], - range: 1..=9, + 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", "realise", "raise"]], + range: 2..=2, }; static WORD_REAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22404,15 +46002,58 @@ pub static WORD_REAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic range: 3..=3, }; +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("mition")], - values: &[&["readmission"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("abilty"), + dictgen::InsensitiveStr::Ascii("ble"), + dictgen::InsensitiveStr::Ascii("by"), + 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("ius"), + dictgen::InsensitiveStr::Ascii("ly"), + dictgen::InsensitiveStr::Ascii("mition"), + dictgen::InsensitiveStr::Ascii("nig"), + dictgen::InsensitiveStr::Ascii("ning"), + dictgen::InsensitiveStr::Ascii("yness"), + ], + values: &[ + &["readability"], + &["readable"], + &["read"], + &["readable"], + &["read", "readd", "readded"], + &["readme"], + &["readable"], + &["readability"], + &["readable"], + &["radius"], + &["readily", "ready"], + &["readmission"], + &["reading"], + &["reading"], + &["readiness"], + ], + range: 2..=7, }; static WORD_REAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22422,26 +46063,87 @@ static WORD_REAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"], + &["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, @@ -22459,13 +46161,13 @@ static WORD_RA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_RAI_NODE), None, None, - None, + Some(&WORD_RAL_NODE), Some(&WORD_RAM_NODE), Some(&WORD_RAN_NODE), Some(&WORD_RAO_NODE), Some(&WORD_RAP_NODE), None, - None, + Some(&WORD_RAR_NODE), Some(&WORD_RAS_NODE), Some(&WORD_RAT_NODE), None, @@ -22483,7 +46185,9 @@ static WORD_RAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_RAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("har"), dictgen::InsensitiveStr::Ascii("hcet"), + dictgen::InsensitiveStr::Ascii("hern"), dictgen::InsensitiveStr::Ascii("ionalizaiton"), dictgen::InsensitiveStr::Ascii("ionalizating"), dictgen::InsensitiveStr::Ascii("ionalizaton"), @@ -22494,7 +46198,9 @@ pub static WORD_RAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("pure"), ], values: &[ + &["rather"], &["ratchet"], + &["rather"], &["rationalization"], &["rationalization"], &["rationalization"], @@ -22504,7 +46210,7 @@ pub static WORD_RAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["rationale"], &["rapture"], ], - range: 4..=12, + range: 3..=12, }; static WORD_RAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22514,12 +46220,46 @@ static WORD_RAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_RAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("berry"), 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"), ], - values: &[&["raspberry"], &["raspberry"], &["raspberry"]], - range: 5..=7, + values: &[ + &["raspberry"], + &["raspberry"], + &["raise"], + &["raised"], + &["raises"], + &["raising"], + &["raising"], + &["reasons"], + &["raspberry"], + &["raspberry"], + &["raspberry"], + ], + range: 2..=7, +}; + +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 { @@ -22530,6 +46270,13 @@ static WORD_RAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_RAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("hsody"), + dictgen::InsensitiveStr::Ascii("lace"), + dictgen::InsensitiveStr::Ascii("lacing"), + dictgen::InsensitiveStr::Ascii("resent"), + dictgen::InsensitiveStr::Ascii("resentation"), + dictgen::InsensitiveStr::Ascii("resented"), + dictgen::InsensitiveStr::Ascii("resenting"), + dictgen::InsensitiveStr::Ascii("resents"), dictgen::InsensitiveStr::Ascii("sberry"), dictgen::InsensitiveStr::Ascii("tores"), dictgen::InsensitiveStr::Ascii("tros"), @@ -22537,12 +46284,19 @@ pub static WORD_RAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["rhapsody"], + &["replace"], + &["replacing"], + &["represent"], + &["representation"], + &["represented"], + &["representing"], + &["represents"], &["raspberry"], &["raptors"], &["raptors"], &["rapture"], ], - range: 4..=6, + range: 4..=11, }; static WORD_RAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22555,9 +46309,29 @@ pub static WORD_RAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"]], - range: 4..=5, + 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 { @@ -22567,7 +46341,9 @@ static WORD_RAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_RAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("dmom"), dictgen::InsensitiveStr::Ascii("dmoness"), + dictgen::InsensitiveStr::Ascii("domally"), dictgen::InsensitiveStr::Ascii("domes"), dictgen::InsensitiveStr::Ascii("domez"), dictgen::InsensitiveStr::Ascii("domns"), @@ -22578,7 +46354,9 @@ pub static WORD_RAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dumness"), ], values: &[ + &["random"], &["randomness"], + &["randomly"], &["randoms"], &["randomized"], &["randoms"], @@ -22588,7 +46366,7 @@ pub static WORD_RAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["randomness"], &["randomness"], ], - range: 5..=7, + range: 4..=7, }; static WORD_RAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22602,6 +46380,17 @@ pub static WORD_RAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -22616,6 +46405,8 @@ pub static WORD_RAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("lrod"), dictgen::InsensitiveStr::Ascii("nbos"), dictgen::InsensitiveStr::Ascii("nbowers"), + dictgen::InsensitiveStr::Ascii("sedd"), + dictgen::InsensitiveStr::Ascii("son"), ], values: &[ &["radiance"], @@ -22625,8 +46416,10 @@ pub static WORD_RAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["railroad"], &["rainbows"], &["rainbows"], + &["raised"], + &["reason", "raisin"], ], - range: 4..=8, + range: 3..=8, }; static WORD_RAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22647,11 +46440,22 @@ static WORD_RAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["realism"], &["really"]], - range: 3..=4, + values: &[ + &["read"], + &["reading"], + &["reads"], + &["ready"], + &["realism"], + &["really"], + ], + range: 1..=4, }; static WORD_RAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22663,9 +46467,12 @@ pub static WORD_RAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("aince"), dictgen::InsensitiveStr::Ascii("aint"), + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("e"), 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"), @@ -22675,14 +46482,20 @@ pub static WORD_RAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("y"), ], values: &[ &["radiance"], &["radiant"], + &["radiation"], + &["read", "raid"], &["radioactive"], &["radiance"], &["radioactive"], + &["radiation"], &["radicals"], &["radicals"], &["raiders"], @@ -22692,9 +46505,12 @@ pub static WORD_RAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["radioactive"], &["radioactive"], &["radioactive"], + &["radiobutton"], &["radioactive"], + &["radix"], + &["ready"], ], - range: 3..=9, + range: 1..=9, }; static WORD_RAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22710,6 +46526,7 @@ pub static WORD_RAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("istas"), dictgen::InsensitiveStr::Ascii("istes"), dictgen::InsensitiveStr::Ascii("thet"), + dictgen::InsensitiveStr::Ascii("tise"), ], values: &[ &["raucous"], @@ -22718,6 +46535,7 @@ pub static WORD_RAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["racists"], &["racists"], &["ratchet"], + &["practise"], ], range: 3..=12, }; @@ -22747,17 +46565,17 @@ static WORD_Q_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, None, None, + Some(&WORD_QE_NODE), + None, + None, + None, + Some(&WORD_QI_NODE), None, None, None, None, None, - None, - None, - None, - None, - None, - None, + Some(&WORD_QO_NODE), None, None, None, @@ -22780,7 +46598,7 @@ static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_QUA_NODE), None, Some(&WORD_QUC_NODE), - None, + Some(&WORD_QUD_NODE), Some(&WORD_QUE_NODE), None, None, @@ -22791,10 +46609,10 @@ static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_QUN_NODE), + Some(&WORD_QUO_NODE), None, None, - None, - None, + Some(&WORD_QUR_NODE), None, Some(&WORD_QUT_NODE), Some(&WORD_QUU_NODE), @@ -22823,10 +46641,39 @@ static WORD_QUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_QUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[dictgen::InsensitiveStr::Ascii("ie")], - values: &[&["quite"]], + values: &[&["quite", "quiet"]], range: 2..=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("taion"), + dictgen::InsensitiveStr::Ascii("teed"), + dictgen::InsensitiveStr::Ascii("ttes"), + ], + values: &[&["quotation"], &["quoted"], &["quotes"]], + range: 4..=5, +}; + static WORD_QUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_QUN_CHILDREN), value: None, @@ -22850,22 +46697,36 @@ pub static WORD_QUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("cket"), dictgen::InsensitiveStr::Ascii("ckets"), + dictgen::InsensitiveStr::Ascii("ckier"), dictgen::InsensitiveStr::Ascii("cklyu"), + dictgen::InsensitiveStr::Ascii("cly"), dictgen::InsensitiveStr::Ascii("elty"), + dictgen::InsensitiveStr::Ascii("essent"), dictgen::InsensitiveStr::Ascii("nessential"), dictgen::InsensitiveStr::Ascii("tely"), + dictgen::InsensitiveStr::Ascii("th"), + dictgen::InsensitiveStr::Ascii("ting"), + dictgen::InsensitiveStr::Ascii("tt"), + dictgen::InsensitiveStr::Ascii("tted"), dictgen::InsensitiveStr::Ascii("zes"), ], values: &[ &["quickest"], &["quickest"], + &["quicker"], + &["quickly"], &["quickly"], &["quietly"], + &["quiescent"], &["quintessential"], - &["quietly"], + &["quietly", "quite"], + &["quit", "with"], + &["quitting"], + &["quit"], + &["quit"], &["quizzes"], ], - range: 3..=10, + range: 2..=10, }; static WORD_QUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -22877,50 +46738,101 @@ pub static WORD_QUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("reis"), + dictgen::InsensitiveStr::Ascii("riable"), + dictgen::InsensitiveStr::Ascii("ring"), + dictgen::InsensitiveStr::Ascii("rries"), + dictgen::InsensitiveStr::Ascii("ryies"), + dictgen::InsensitiveStr::Ascii("ryinterace"), + dictgen::InsensitiveStr::Ascii("rys"), + dictgen::InsensitiveStr::Ascii("siton"), dictgen::InsensitiveStr::Ascii("sitonable"), dictgen::InsensitiveStr::Ascii("sitoned"), dictgen::InsensitiveStr::Ascii("sitoning"), + dictgen::InsensitiveStr::Ascii("sitons"), + dictgen::InsensitiveStr::Ascii("stionaire"), dictgen::InsensitiveStr::Ascii("stional"), dictgen::InsensitiveStr::Ascii("stionalbe"), dictgen::InsensitiveStr::Ascii("stionalble"), 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"], &["queries"], + &["queryable"], + &["querying"], + &["queries"], + &["queries"], + &["queryinterface"], + &["queries"], + &["question"], &["questionable"], &["questioned"], &["questioning"], + &["questions"], + &["questionnaire"], &["questionable"], &["questionable"], &["questionable"], &["questioned"], &["questioning"], &["questioning"], + &["questionnaire"], &["questioned"], &["questioned"], &["questioning"], &["questioning"], + &["question"], + &["questions"], &["questionable"], + &["queue"], + &["queued"], + &["queues"], + &["queue"], ], - range: 4..=10, + 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 { @@ -22929,75 +46841,198 @@ static WORD_QUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_QUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ikest")], - values: &[&["quickest"]], - range: 5..=5, + 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::Flat(&WORD_QUA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_QUA_CHILDREN), value: None, }; -pub static WORD_QUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_QUA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + None, + None, + Some(&WORD_QUAD_NODE), + None, + None, + 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("ilfiers"), - dictgen::InsensitiveStr::Ascii("ilfy"), - dictgen::InsensitiveStr::Ascii("ilty"), - dictgen::InsensitiveStr::Ascii("lfiiers"), - dictgen::InsensitiveStr::Ascii("lifiaction"), - dictgen::InsensitiveStr::Ascii("lifiactions"), - dictgen::InsensitiveStr::Ascii("lificaiton"), - dictgen::InsensitiveStr::Ascii("lificaitons"), - dictgen::InsensitiveStr::Ascii("lificato"), - dictgen::InsensitiveStr::Ascii("lificaton"), - dictgen::InsensitiveStr::Ascii("lificatons"), - dictgen::InsensitiveStr::Ascii("lifieds"), - dictgen::InsensitiveStr::Ascii("lifierais"), - dictgen::InsensitiveStr::Ascii("lifieres"), - dictgen::InsensitiveStr::Ascii("lifiies"), - dictgen::InsensitiveStr::Ascii("lifiing"), - dictgen::InsensitiveStr::Ascii("lifikation"), - dictgen::InsensitiveStr::Ascii("lifires"), - dictgen::InsensitiveStr::Ascii("lifiy"), - dictgen::InsensitiveStr::Ascii("lifyers"), - dictgen::InsensitiveStr::Ascii("litying"), - dictgen::InsensitiveStr::Ascii("ltitative"), - dictgen::InsensitiveStr::Ascii("nitfy"), - dictgen::InsensitiveStr::Ascii("nitites"), - dictgen::InsensitiveStr::Ascii("ntaties"), - dictgen::InsensitiveStr::Ascii("ntatitive"), - dictgen::InsensitiveStr::Ascii("ntaty"), - dictgen::InsensitiveStr::Ascii("ntifiy"), - dictgen::InsensitiveStr::Ascii("ntitaive"), - dictgen::InsensitiveStr::Ascii("ntitatve"), - dictgen::InsensitiveStr::Ascii("ntite"), - dictgen::InsensitiveStr::Ascii("ntitites"), - dictgen::InsensitiveStr::Ascii("ntititive"), - dictgen::InsensitiveStr::Ascii("ntitiy"), - dictgen::InsensitiveStr::Ascii("ntitize"), - dictgen::InsensitiveStr::Ascii("ntitties"), - dictgen::InsensitiveStr::Ascii("ntitty"), - dictgen::InsensitiveStr::Ascii("ntuum"), - dictgen::InsensitiveStr::Ascii("rantaine"), - dictgen::InsensitiveStr::Ascii("rante"), - dictgen::InsensitiveStr::Ascii("rantena"), - dictgen::InsensitiveStr::Ascii("rantene"), - dictgen::InsensitiveStr::Ascii("rantenni"), - dictgen::InsensitiveStr::Ascii("rantied"), - dictgen::InsensitiveStr::Ascii("rintine"), - dictgen::InsensitiveStr::Ascii("rterbackers"), - dictgen::InsensitiveStr::Ascii("rterblack"), - dictgen::InsensitiveStr::Ascii("rtercask"), - dictgen::InsensitiveStr::Ascii("rtery"), - dictgen::InsensitiveStr::Ascii("rtlery"), - dictgen::InsensitiveStr::Ascii("runtine"), + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("ing"), + ], + values: &[&["quotation"], &["quarter"], &["quoting", "squatting"]], + 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("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"], + &["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("itified"), + dictgen::InsensitiveStr::Ascii("itites"), + 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("titiy"), + dictgen::InsensitiveStr::Ascii("titize"), + dictgen::InsensitiveStr::Ascii("titties"), + dictgen::InsensitiveStr::Ascii("titty"), + dictgen::InsensitiveStr::Ascii("tuum"), + ], + values: &[ + &["quantify"], + &["quantified"], + &["quantities"], + &["qualification", "quantification"], + &["qualified", "quantified"], + &["qualifies", "quantifies"], + &["qualify", "quantify"], + &["quantities"], + &["quantitative"], + &["quantity"], + &["quantify"], + &["quantitative"], + &["quantitative"], + &["quantities"], + &["quantities"], + &["quantitative"], + &["quantity"], + &["quantities"], + &["quantities"], + &["quantity"], + &["quantum"], + ], + range: 4..=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"], - &["quality"], - &["qualifiers"], + &["qualifier"], &["qualification"], &["qualification"], &["qualifications"], @@ -23014,39 +47049,42 @@ pub static WORD_QUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["qualifiers"], &["qualify"], &["qualifiers"], + &["qualification"], + &["qualifications"], &["qualifying"], &["quantitative"], - &["quantify"], - &["quantities"], - &["quantities"], - &["quantitative"], - &["quantity"], - &["quantify"], - &["quantitative"], - &["quantitative"], - &["quantities"], - &["quantities"], - &["quantitative"], - &["quantity"], - &["quantities"], - &["quantities"], - &["quantity"], - &["quantum"], - &["quarantine"], - &["quarantine"], - &["quarantine"], - &["quarantine"], - &["quarantine"], - &["quarantine"], - &["quarantine"], - &["quarterbacks"], - &["quarterback"], - &["quarterbacks"], - &["quarterly"], - &["quarterly"], - &["quarantine"], ], - range: 4..=11, + 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_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"), + ], + values: &[&["quaddec"], &["quadrangle"]], + range: 4..=5, }; static WORD_QT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23056,10 +47094,48 @@ static WORD_QT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_QT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[dictgen::InsensitiveStr::Ascii("uie")], - values: &[&["quite"]], + 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("th")], + values: &[&["with"]], + range: 2..=2, +}; + +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("ueue")], + values: &[&["queue"]], + range: 4..=4, +}; + static WORD_QA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_QA_CHILDREN), value: None, @@ -23120,7 +47196,7 @@ static WORD_P_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_PU_NODE), None, Some(&WORD_PW_NODE), - None, + Some(&WORD_PX_NODE), Some(&WORD_PY_NODE), None, ]; @@ -23133,10 +47209,16 @@ static WORD_PY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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"), @@ -23157,13 +47239,25 @@ pub static WORD_PY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("schosis"), dictgen::InsensitiveStr::Ascii("schotic"), dictgen::InsensitiveStr::Ascii("scic"), + dictgen::InsensitiveStr::Ascii("thin"), + dictgen::InsensitiveStr::Ascii("thjon"), + dictgen::InsensitiveStr::Ascii("tnon"), + dictgen::InsensitiveStr::Ascii("tohn"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tyon"), ], values: &[ &["pyramid"], - &["pyramids"], + &["python"], + &["physical"], + &["python"], + &["python"], &["pyramids"], &["pyramid"], &["pyramids"], + &["pyramid"], + &["pyramids"], + &["python"], &["pyramids"], &["pyramid"], &["pyramids"], @@ -23184,8 +47278,29 @@ pub static WORD_PY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["psychosis"], &["psychotic"], &["psychic"], + &["python"], + &["python"], + &["python"], + &["python"], + &["python"], + &["python"], ], - range: 4..=13, + 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 { @@ -23251,11 +47366,12 @@ static WORD_PUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_PUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ehd"), dictgen::InsensitiveStr::Ascii("hpus"), dictgen::InsensitiveStr::Ascii("usading"), ], - values: &[&["pushups"], &["persuading"]], - range: 4..=7, + values: &[&["pushed"], &["pushups"], &["persuading"]], + range: 3..=7, }; static WORD_PUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23266,12 +47382,14 @@ static WORD_PUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("gest"), dictgen::InsensitiveStr::Ascii("hcased"), dictgen::InsensitiveStr::Ascii("itannical"), dictgen::InsensitiveStr::Ascii("pendicular"), @@ -23283,8 +47401,10 @@ pub static WORD_PUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -23292,12 +47412,14 @@ pub static WORD_PUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["purgatory"], + &["purchased"], &["purchase"], &["purchased"], &["purchases"], &["purchasing"], &["purchasing"], &["purchasing"], + &["purges"], &["purchased"], &["puritanical"], &["perpendicular"], @@ -23309,14 +47431,16 @@ pub static WORD_PUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["purposely"], &["purposely"], &["purportedly"], + &["purpose"], &["purposefully"], &["pursuit"], + &["persuade"], &["persuaded"], &["persuades"], &["pursued"], &["pursued"], ], - range: 4..=10, + range: 3..=10, }; static WORD_PUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23326,11 +47450,30 @@ static WORD_PUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ulated"), ], - values: &[&["publications"], &["publisher"]], - range: 6..=9, + values: &[ + &["popular"], + &["popularity"], + &["populate"], + &["populated"], + &["populates"], + &["populating"], + &["population"], + &["publications"], + &["publisher"], + &["populated"], + ], + range: 3..=9, }; static WORD_PUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23340,6 +47483,7 @@ static WORD_PUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ihsment"), @@ -23358,6 +47502,7 @@ pub static WORD_PUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("sihments"), ], values: &[ + &["punctuation"], &["punctuation"], &["punctuation"], &["punishments"], @@ -23400,9 +47545,12 @@ static WORD_PUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_PUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("isher")], - values: &[&["publisher"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("isher"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[&["publisher"], &["pulse", "plus"]], + range: 1..=5, }; static WORD_PUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23442,64 +47590,197 @@ pub static WORD_PUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_PUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PUB_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PUB_CHILDREN), value: None, }; -pub static WORD_PUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ilsher"), - dictgen::InsensitiveStr::Ascii("isher"), - dictgen::InsensitiveStr::Ascii("liaher"), - dictgen::InsensitiveStr::Ascii("licaly"), - dictgen::InsensitiveStr::Ascii("licani"), - dictgen::InsensitiveStr::Ascii("licher"), - dictgen::InsensitiveStr::Ascii("licitan"), - dictgen::InsensitiveStr::Ascii("liclly"), - dictgen::InsensitiveStr::Ascii("licy"), - dictgen::InsensitiveStr::Ascii("lihser"), - dictgen::InsensitiveStr::Ascii("likation"), - dictgen::InsensitiveStr::Ascii("lisehr"), - dictgen::InsensitiveStr::Ascii("liser"), - dictgen::InsensitiveStr::Ascii("lisger"), - dictgen::InsensitiveStr::Ascii("lisheed"), - dictgen::InsensitiveStr::Ascii("lisherr"), - dictgen::InsensitiveStr::Ascii("lishher"), - dictgen::InsensitiveStr::Ascii("lishor"), - dictgen::InsensitiveStr::Ascii("lishre"), - dictgen::InsensitiveStr::Ascii("lissher"), - dictgen::InsensitiveStr::Ascii("llisher"), - dictgen::InsensitiveStr::Ascii("lsih"), - dictgen::InsensitiveStr::Ascii("lsiher"), - dictgen::InsensitiveStr::Ascii("lusher"), + 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("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("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: &[ - &["publisher"], - &["publisher"], + &["public", "pubic"], + &["publication"], + &["publicise"], + &["publicize"], &["publisher"], &["publicly"], + &["publicly"], &["publication"], + &["publish", "public"], + &["published"], &["publisher"], + &["publishers"], + &["publishes"], + &["publishing"], &["publication"], &["publicly"], &["publicly"], + &["published"], &["publisher"], &["publication"], + &["published"], + &["published"], &["publisher"], + &["publishers"], &["publisher"], + &["publishers"], + &["published"], &["publisher"], + &["publishers"], + &["published"], &["published"], &["publisher"], &["publisher"], &["publisher"], &["publisher"], &["publisher"], + &["publishers"], + &["publisher"], &["publisher"], &["publish"], + &["published"], &["publisher"], + &["publishers"], + &["publishing"], + &["publish"], + &["published"], &["publisher"], + &["publishers"], + &["publishes"], + &["publishing"], + &["public"], + &["publication"], + &["publish"], + &["publisher"], + &["publishers"], + &["publishes"], + &["publishing"], ], - range: 4..=8, + 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 { @@ -23520,20 +47801,36 @@ static WORD_PT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), ], values: &[ + &["pdf"], + &["pthread"], + &["pthreads"], + &["python"], + &["pthread"], + &["pthreads"], &["pitched"], &["pitcher"], &["pitchers"], &["pitchfork"], &["pitchforks"], + &["portions"], + &["press"], ], - range: 5..=8, + range: 1..=8, }; static WORD_PS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23542,7 +47839,7 @@ static WORD_PS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_PSA_NODE), None, Some(&WORD_PSC_NODE), None, @@ -23556,11 +47853,11 @@ static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, + Some(&WORD_PSO_NODE), None, None, - None, - None, - None, + Some(&WORD_PSR_NODE), + Some(&WORD_PSS_NODE), None, Some(&WORD_PSU_NODE), None, @@ -23577,6 +47874,7 @@ static WORD_PSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -23628,6 +47926,7 @@ pub static WORD_PSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("siological"), ], values: &[ + &["psychedelic"], &["psychiatric"], &["psychiatrist"], &["psychiatrists"], @@ -23687,9 +47986,53 @@ static WORD_PSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_PSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("edo")], - values: &[&["pseudo"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("do"), + dictgen::InsensitiveStr::Ascii("edo"), + dictgen::InsensitiveStr::Ascii("edolayer"), + dictgen::InsensitiveStr::Ascii("h"), + ], + values: &[&["pseudo"], &["pseudo"], &["pseudolayer"], &["push"]], + range: 1..=8, +}; + +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 { @@ -23702,9 +48045,19 @@ pub static WORD_PSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"]], - range: 9..=12, + values: &[ + &["psychological"], + &["psychologically"], + &["psychologist"], + &["position"], + &["positioned"], + &["positions"], + ], + range: 4..=12, }; static WORD_PSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23751,11 +48104,20 @@ static WORD_PSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_PSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ude"), dictgen::InsensitiveStr::Ascii("udononymous"), dictgen::InsensitiveStr::Ascii("udonyn"), + dictgen::InsensitiveStr::Ascii("udopoential"), + dictgen::InsensitiveStr::Ascii("udopoentials"), ], - values: &[&["pseudonymous"], &["pseudonym"]], - range: 6..=11, + values: &[ + &["pseudo"], + &["pseudonymous"], + &["pseudonym"], + &["pseudopotential"], + &["pseudopotentials"], + ], + range: 3..=12, }; static WORD_PSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -23797,6 +48159,21 @@ pub static WORD_PSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("ces"), + dictgen::InsensitiveStr::Ascii("swd"), + ], + values: &[&["space"], &["spaces"], &["passwd"]], + range: 2..=3, +}; + static WORD_PR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_PR_CHILDREN), value: None, @@ -23806,25 +48183,25 @@ static WORD_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_PRA_NODE), None, Some(&WORD_PRC_NODE), - None, + Some(&WORD_PRD_NODE), Some(&WORD_PRE_NODE), - None, - None, + Some(&WORD_PRF_NODE), + Some(&WORD_PRG_NODE), None, Some(&WORD_PRI_NODE), None, None, None, - None, + Some(&WORD_PRM_NODE), None, Some(&WORD_PRO_NODE), + Some(&WORD_PRP_NODE), None, + Some(&WORD_PRR_NODE), None, - None, - None, - None, + Some(&WORD_PRT_NODE), Some(&WORD_PRU_NODE), - None, + Some(&WORD_PRV_NODE), None, None, Some(&WORD_PRY_NODE), @@ -23845,6 +48222,17 @@ pub static WORD_PRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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")], + values: &[&["private"]], + range: 4..=4, +}; + static WORD_PRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PRU_CHILDREN), value: None, @@ -23855,6 +48243,7 @@ pub static WORD_PRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -23864,12 +48253,65 @@ pub static WORD_PRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["purchase"], &["purchased"], &["purchases"], + &["proof"], &["purgatory"], &["purposefully"], &["purposely"], &["pursuit"], ], - range: 4..=9, + 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_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 { @@ -23882,11 +48324,11 @@ static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_PROB_NODE), Some(&WORD_PROC_NODE), Some(&WORD_PROD_NODE), - None, + Some(&WORD_PROE_NODE), Some(&WORD_PROF_NODE), Some(&WORD_PROG_NODE), Some(&WORD_PROH_NODE), - None, + Some(&WORD_PROI_NODE), Some(&WORD_PROJ_NODE), Some(&WORD_PROK_NODE), Some(&WORD_PROL_NODE), @@ -23895,17 +48337,53 @@ static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_PROO_NODE), Some(&WORD_PROP_NODE), None, - 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), - None, - None, + 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, @@ -23926,17 +48404,38 @@ pub static WORD_PROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("acative"), dictgen::InsensitiveStr::Ascii("acotive"), + dictgen::InsensitiveStr::Ascii("ate"), dictgen::InsensitiveStr::Ascii("ded"), + dictgen::InsensitiveStr::Ascii("der"), + dictgen::InsensitiveStr::Ascii("dided"), + dictgen::InsensitiveStr::Ascii("didet"), + dictgen::InsensitiveStr::Ascii("die"), + dictgen::InsensitiveStr::Ascii("died"), + dictgen::InsensitiveStr::Ascii("dies"), + dictgen::InsensitiveStr::Ascii("ding"), + dictgen::InsensitiveStr::Ascii("edd"), dictgen::InsensitiveStr::Ascii("encial"), dictgen::InsensitiveStr::Ascii("erai"), dictgen::InsensitiveStr::Ascii("eribal"), dictgen::InsensitiveStr::Ascii("ervial"), dictgen::InsensitiveStr::Ascii("icative"), + dictgen::InsensitiveStr::Ascii("icde"), + dictgen::InsensitiveStr::Ascii("icded"), + dictgen::InsensitiveStr::Ascii("icdes"), + dictgen::InsensitiveStr::Ascii("ice"), dictgen::InsensitiveStr::Ascii("icial"), + dictgen::InsensitiveStr::Ascii("id"), dictgen::InsensitiveStr::Ascii("idance"), dictgen::InsensitiveStr::Ascii("idee"), dictgen::InsensitiveStr::Ascii("idencie"), + dictgen::InsensitiveStr::Ascii("idewd"), + dictgen::InsensitiveStr::Ascii("idfers"), dictgen::InsensitiveStr::Ascii("idince"), + dictgen::InsensitiveStr::Ascii("ids"), + dictgen::InsensitiveStr::Ascii("idse"), + dictgen::InsensitiveStr::Ascii("ie"), + dictgen::InsensitiveStr::Ascii("ied"), + dictgen::InsensitiveStr::Ascii("ies"), dictgen::InsensitiveStr::Ascii("inciaal"), dictgen::InsensitiveStr::Ascii("inciae"), dictgen::InsensitiveStr::Ascii("incie"), @@ -23948,7 +48447,10 @@ pub static WORD_PROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("inicial"), dictgen::InsensitiveStr::Ascii("intial"), dictgen::InsensitiveStr::Ascii("invial"), + dictgen::InsensitiveStr::Ascii("isioing"), dictgen::InsensitiveStr::Ascii("isiones"), + dictgen::InsensitiveStr::Ascii("isiong"), + dictgen::InsensitiveStr::Ascii("isionging"), dictgen::InsensitiveStr::Ascii("isios"), dictgen::InsensitiveStr::Ascii("isiosn"), dictgen::InsensitiveStr::Ascii("isonal"), @@ -23958,22 +48460,46 @@ pub static WORD_PROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ocativley"), dictgen::InsensitiveStr::Ascii("ocitive"), dictgen::InsensitiveStr::Ascii("ocotive"), + dictgen::InsensitiveStr::Ascii("ode"), + dictgen::InsensitiveStr::Ascii("oding"), dictgen::InsensitiveStr::Ascii("okative"), + dictgen::InsensitiveStr::Ascii("sioning"), ], values: &[ &["provocative"], &["provocative"], + &["private", "provide"], &["provided"], + &["provider"], + &["provided"], + &["provided", "provider", "provident"], + &["provide"], + &["provided"], + &["provides"], + &["providing"], + &["proved", "provided"], &["provincial"], &["proverbial"], &["proverbial"], &["proverbial"], &["provocative"], + &["provide"], + &["provided"], + &["provides"], + &["provide", "province"], &["provincial"], + &["provide", "prove", "proved", "proves"], &["providence"], &["providence"], &["providence"], + &["provided"], + &["providers"], &["providence"], + &["provides", "proves"], + &["provides", "provide"], + &["provide", "prove"], + &["provide", "provided", "proved"], + &["provides", "proves"], &["provincial"], &["province"], &["province"], @@ -23985,7 +48511,10 @@ pub static WORD_PROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["provincial"], &["provincial"], &["provincial"], + &["provisioning"], &["provisions"], + &["provisioning"], + &["provisioning"], &["provisions"], &["provision"], &["provisional"], @@ -23995,9 +48524,12 @@ pub static WORD_PROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["provocative"], &["provocative"], &["provocative"], + &["provide"], + &["providing"], &["provocative"], + &["provisioning"], ], - range: 3..=9, + range: 2..=9, }; static WORD_PROU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -24022,7 +48554,7 @@ static WORD_PROT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_PROT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_PROTA_NODE), None, - None, + Some(&WORD_PROTC_NODE), None, Some(&WORD_PROTE_NODE), Some(&WORD_PROTF_NODE), @@ -24101,13 +48633,17 @@ static WORD_PROTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("cal"), + dictgen::InsensitiveStr::Ascii("cals"), dictgen::InsensitiveStr::Ascii("cl"), + 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("ganist"), dictgen::InsensitiveStr::Ascii("ganists"), + dictgen::InsensitiveStr::Ascii("ge"), dictgen::InsensitiveStr::Ascii("gonist"), dictgen::InsensitiveStr::Ascii("hypes"), dictgen::InsensitiveStr::Ascii("stant"), @@ -24117,17 +48653,26 @@ pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("ypes"), + dictgen::InsensitiveStr::Ascii("ytpe"), + dictgen::InsensitiveStr::Ascii("ytpes"), ], values: &[ + &["protocol"], + &["protocols"], &["protocol"], &["protocol"], &["protocols"], + &["protocol"], &["protocols"], &["protocols"], &["protocol"], &["protagonist"], &["protagonists"], + &["protege"], &["protagonist"], &["prototypes"], &["protestant"], @@ -24138,6 +48683,11 @@ pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["prototypes"], &["prototype"], &["prototypes"], + &["prototypes"], + &["prototype"], + &["prototypes"], + &["prototype"], + &["prototypes"], ], range: 2..=7, }; @@ -24193,6 +48743,7 @@ static WORD_PROTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -24201,6 +48752,7 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -24208,9 +48760,11 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ctos"), dictgen::InsensitiveStr::Ascii("ctron"), dictgen::InsensitiveStr::Ascii("ctrons"), + dictgen::InsensitiveStr::Ascii("dcted"), 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"), @@ -24224,17 +48778,20 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("stes"), dictgen::InsensitiveStr::Ascii("stina"), dictgen::InsensitiveStr::Ascii("stos"), + dictgen::InsensitiveStr::Ascii("xt"), ], values: &[ + &["protection"], &["protection"], &["protections"], &["protects"], - &["protective"], + &["protective", "protected", "protect"], &["protects"], &["protective"], &["protective"], &["protective"], &["protections"], + &["protective"], &["protections"], &["protectors"], &["protectors"], @@ -24242,9 +48799,11 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["protectors"], &["protection"], &["protections"], + &["protected"], &["proteins"], &["proteins"], &["proletariat"], + &["potential"], &["protests"], &["protests"], &["protestants"], @@ -24258,10 +48817,27 @@ pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["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("ool"), + dictgen::InsensitiveStr::Ascii("ools"), + dictgen::InsensitiveStr::Ascii("ted"), + ], + values: &[&["protocol"], &["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, @@ -24324,6 +48900,8 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -24339,6 +48917,7 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -24384,6 +48963,8 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prosecuted"], &["proselytizing"], &["prospect"], + &["process"], + &["processor"], &["prosecuted"], &["prosecution"], &["prosecutor"], @@ -24399,6 +48980,7 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prospective"], &["prosthetic"], &["prosperous"], + &["processes", "possesses"], &["prosthetic"], &["prosperity"], &["prosthetic"], @@ -24433,7 +49015,18 @@ pub static WORD_PROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prostitutes"], &["prostitute"], ], - range: 4..=11, + 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")], + values: &[&["priority"]], + range: 3..=3, }; static WORD_PROP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -24443,12 +49036,12 @@ static WORD_PROP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_PROPA_NODE), - None, + Some(&WORD_PROPB_NODE), None, None, Some(&WORD_PROPE_NODE), None, - None, + Some(&WORD_PROPG_NODE), Some(&WORD_PROPH_NODE), Some(&WORD_PROPI_NODE), None, @@ -24461,15 +49054,26 @@ static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_PROPR_NODE), Some(&WORD_PROPS_NODE), - None, + Some(&WORD_PROPT_NODE), Some(&WORD_PROPU_NODE), - None, + 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, @@ -24493,6 +49097,21 @@ pub static WORD_PROPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -24532,6 +49151,17 @@ pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ietory"), dictgen::InsensitiveStr::Ascii("ietry"), dictgen::InsensitiveStr::Ascii("iotary"), + dictgen::InsensitiveStr::Ascii("oable"), + dictgen::InsensitiveStr::Ascii("oably"), + 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"), @@ -24547,6 +49177,17 @@ pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["proprietary"], &["proprietary"], &["proprietary"], + &["probable"], + &["probably"], + &["propagate"], + &["propagated"], + &["propagates"], + &["propagating"], + &["propagation"], + &["propagations"], + &["propagator"], + &["propagators"], + &["properties"], &["proportion"], &["proportional"], &["proportionally"], @@ -24562,10 +49203,11 @@ static WORD_PROPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), ], - values: &[&["proper"], &["properly"]], + values: &[&["properly"], &["proper"], &["properly"]], range: 2..=4, }; @@ -24576,9 +49218,12 @@ static WORD_PROPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("agate"), 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"), @@ -24588,6 +49233,8 @@ pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -24609,13 +49256,19 @@ pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], &["propaganda"], &["propagate"], + &["propagated"], &["propagates"], + &["propagating"], &["propagation"], &["propulsion"], &["proponents"], @@ -24625,6 +49278,8 @@ pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["proponents"], &["proportion"], &["proposition"], + &["proportion"], + &["proportional"], &["proportional"], &["proportionally"], &["proportions"], @@ -24646,8 +49301,11 @@ pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["proposes"], &["propose"], &["preposterous"], + &["proposition"], &["proportions"], - &["proportions"], + &["proportion", "promotion"], + &["proportional", "promotional"], + &["proportions", "promotions"], ], range: 3..=11, }; @@ -24659,11 +49317,20 @@ static WORD_PROPM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_PROPM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("t"), dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("ter"), dictgen::InsensitiveStr::Ascii("tly"), + dictgen::InsensitiveStr::Ascii("ts"), ], - values: &[&["prompted"], &["promptly"]], - range: 3..=3, + values: &[ + &["prompt"], + &["prompted"], + &["prompter"], + &["promptly"], + &["prompts"], + ], + range: 1..=3, }; static WORD_PROPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -24672,9 +49339,12 @@ static WORD_PROPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_PROPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("usion")], - values: &[&["propulsion"]], - range: 5..=5, + 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 { @@ -24686,9 +49356,16 @@ pub static WORD_PROPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("ertary"), dictgen::InsensitiveStr::Ascii("etary"), + dictgen::InsensitiveStr::Ascii("gate"), + dictgen::InsensitiveStr::Ascii("gation"), ], - values: &[&["proprietary"], &["proprietary"]], - range: 5..=6, + values: &[ + &["proprietary"], + &["proprietary"], + &["propagate"], + &["propagation"], + ], + range: 4..=6, }; static WORD_PROPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -24718,6 +49395,17 @@ pub static WORD_PROPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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")], + values: &[&["propagated"]], + range: 4..=4, +}; + static WORD_PROPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PROPE_CHILDREN), value: None, @@ -24730,20 +49418,41 @@ pub static WORD_PROPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("ries"), dictgen::InsensitiveStr::Ascii("ritary"), dictgen::InsensitiveStr::Ascii("rites"), + dictgen::InsensitiveStr::Ascii("rities"), + 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("rtiary"), + dictgen::InsensitiveStr::Ascii("rtie"), 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("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"], @@ -24751,22 +49460,54 @@ pub static WORD_PROPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["prophecy"], &["prophet"], &["prophets"], + &["properly"], &["propensity"], &["proponents"], &["properties"], + &["properties"], &["proprietary"], &["properties"], + &["properties"], + &["properties"], + &["property"], + &["property", "properly"], + &["properties"], &["propensity"], + &["property"], + &["properties"], + &["property"], &["proprietary"], + &["property", "properties"], &["proportion"], &["proportional"], &["proportions"], &["properties"], + &["properties"], + &["property", "properly"], &["property"], + &["properties"], + &["properties"], + &["properties"], + &["property", "properly"], &["preposterous"], &["properties"], + &["property"], + &["properties"], + &["property"], + &["properties"], ], - range: 2..=7, + 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 { @@ -24777,11 +49518,25 @@ static WORD_PROPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("tagion"), + dictgen::InsensitiveStr::Ascii("tor"), + dictgen::InsensitiveStr::Ascii("tors"), ], - values: &[&["probabilities"], &["propaganda"], &["propaganda"]], - range: 4..=8, + values: &[ + &["probabilities"], + &["probably"], + &["propaganda"], + &["propaganda"], + &["propagate"], + &["propagation"], + &["propagator"], + &["propagators"], + ], + range: 2..=8, }; static WORD_PROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -24791,11 +49546,76 @@ static WORD_PROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["prove"], &["proved"]], - range: 2..=3, + 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 { @@ -24805,9 +49625,11 @@ static WORD_PRON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -24820,6 +49642,7 @@ pub static WORD_PRON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -24829,9 +49652,11 @@ pub static WORD_PRON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("untiation"), ], values: &[ + &["pronounced"], &["pornography"], &["pronominal"], &["pronunciation"], + &["pronounce"], &["pronounced"], &["pronunciation"], &["pronounced"], @@ -24844,6 +49669,7 @@ pub static WORD_PRON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["pronouns"], &["pronouncing"], &["pronouns"], + &["pronounce"], &["pronunciation"], &["pronunciation"], &["pronunciation"], @@ -24881,12 +49707,21 @@ pub static WORD_PROM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ixity"), + dictgen::InsensitiveStr::Ascii("mpt"), + dictgen::InsensitiveStr::Ascii("mpts"), dictgen::InsensitiveStr::Ascii("ocional"), dictgen::InsensitiveStr::Ascii("ose"), dictgen::InsensitiveStr::Ascii("oteurs"), @@ -24896,12 +49731,16 @@ pub static WORD_PROM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("tply"), dictgen::InsensitiveStr::Ascii("tps"), + dictgen::InsensitiveStr::Ascii("ts"), ], values: &[ &["prominently"], @@ -24920,15 +49759,24 @@ pub static WORD_PROM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prominent"], &["prominently"], &["prominently"], + &["prominently", "predominately"], &["prominently"], &["prominently"], - &["prominently"], + &["promise"], &["promiscuous"], &["promiscuous"], &["promiscuous"], &["promiscuous"], &["promiscuous"], &["promiscuous"], + &["promise"], + &["promise", "promises", "promised"], + &["promised"], + &["promises"], + &["promising"], + &["proximity"], + &["prompt"], + &["prompts"], &["promotional"], &["promotes"], &["promotes"], @@ -24938,14 +49786,18 @@ pub static WORD_PROM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["promotes"], &["promoted"], &["promptly"], + &["prompted"], + &["prompts"], &["prompts"], &["prompts"], &["promptly"], &["promiscuous"], + &["prompt"], &["promptly"], &["prompts"], + &["prompts"], ], - range: 3..=8, + range: 1..=8, }; static WORD_PROL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -24956,6 +49808,9 @@ static WORD_PROL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ems"), dictgen::InsensitiveStr::Ascii("etariaat"), dictgen::InsensitiveStr::Ascii("etariant"), dictgen::InsensitiveStr::Ascii("etaricat"), @@ -24970,6 +49825,9 @@ pub static WORD_PROL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["proletariat"], + &["problems"], + &["problem"], + &["problems"], &["proletariat"], &["proletariat"], &["proletariat"], @@ -24982,7 +49840,7 @@ pub static WORD_PROL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prolegomena"], &["prologue"], ], - range: 3..=8, + range: 2..=8, }; static WORD_PROK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25003,6 +49861,12 @@ static WORD_PROJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("ecitle"), dictgen::InsensitiveStr::Ascii("ecte"), dictgen::InsensitiveStr::Ascii("ecticle"), @@ -25012,6 +49876,7 @@ pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -25022,6 +49887,12 @@ pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ektion"), ], values: &[ + &["project"], + &["projection"], + &["projections"], + &["projector"], + &["projectors"], + &["projects"], &["projectiles"], &["projectile"], &["projectile"], @@ -25031,6 +49902,7 @@ pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["projectiles"], &["projectiles"], &["projection"], + &["projection"], &["projectiles"], &["projectiles"], &["projectiles"], @@ -25040,7 +49912,18 @@ pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["projectile"], &["projection"], ], - range: 4..=8, + 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")], + values: &[&["priority"]], + range: 4..=4, }; static WORD_PROH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25068,6 +49951,9 @@ pub static WORD_PROH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -25094,6 +49980,9 @@ pub static WORD_PROH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prohibited"], &["prohibit"], &["prohibited"], + &["prohibiting"], + &["prohibits"], + &["prohibited"], &["prophecies"], &["prophecy"], &["prophet"], @@ -25103,136 +49992,450 @@ pub static WORD_PROH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_PROG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PROG_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PROG_CHILDREN), value: None, }; -pub static WORD_PROG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("atonists"), - dictgen::InsensitiveStr::Ascii("erssion"), - dictgen::InsensitiveStr::Ascii("erssive"), - dictgen::InsensitiveStr::Ascii("essed"), - dictgen::InsensitiveStr::Ascii("idy"), - dictgen::InsensitiveStr::Ascii("ramable"), - dictgen::InsensitiveStr::Ascii("ramas"), - dictgen::InsensitiveStr::Ascii("ramattically"), - dictgen::InsensitiveStr::Ascii("ramem"), - dictgen::InsensitiveStr::Ascii("rames"), - dictgen::InsensitiveStr::Ascii("rammar"), - dictgen::InsensitiveStr::Ascii("rammare"), - dictgen::InsensitiveStr::Ascii("rammars"), - dictgen::InsensitiveStr::Ascii("rammate"), - dictgen::InsensitiveStr::Ascii("rammets"), - dictgen::InsensitiveStr::Ascii("rammeur"), - dictgen::InsensitiveStr::Ascii("rammeurs"), - dictgen::InsensitiveStr::Ascii("rammier"), - dictgen::InsensitiveStr::Ascii("rammme"), - dictgen::InsensitiveStr::Ascii("rammmed"), - dictgen::InsensitiveStr::Ascii("rammmer"), - dictgen::InsensitiveStr::Ascii("ramms"), - dictgen::InsensitiveStr::Ascii("rastination"), - dictgen::InsensitiveStr::Ascii("resing"), - dictgen::InsensitiveStr::Ascii("resion"), - dictgen::InsensitiveStr::Ascii("resison"), - dictgen::InsensitiveStr::Ascii("resive"), - dictgen::InsensitiveStr::Ascii("ressers"), - dictgen::InsensitiveStr::Ascii("ressie"), - dictgen::InsensitiveStr::Ascii("ressief"), - dictgen::InsensitiveStr::Ascii("ressieve"), - dictgen::InsensitiveStr::Ascii("ressin"), - dictgen::InsensitiveStr::Ascii("ressino"), - dictgen::InsensitiveStr::Ascii("ressioin"), - dictgen::InsensitiveStr::Ascii("ressiong"), - dictgen::InsensitiveStr::Ascii("ressionists"), - dictgen::InsensitiveStr::Ascii("ressionwise"), - dictgen::InsensitiveStr::Ascii("ressisme"), - dictgen::InsensitiveStr::Ascii("ressiste"), - dictgen::InsensitiveStr::Ascii("ressivas"), - dictgen::InsensitiveStr::Ascii("ressivelly"), - dictgen::InsensitiveStr::Ascii("ressivey"), - dictgen::InsensitiveStr::Ascii("ressivily"), - dictgen::InsensitiveStr::Ascii("ressivisme"), - dictgen::InsensitiveStr::Ascii("ressivley"), - dictgen::InsensitiveStr::Ascii("ressivly"), - dictgen::InsensitiveStr::Ascii("ressivo"), - dictgen::InsensitiveStr::Ascii("ressivsm"), - dictgen::InsensitiveStr::Ascii("resso"), - dictgen::InsensitiveStr::Ascii("ressoin"), - dictgen::InsensitiveStr::Ascii("resson"), - dictgen::InsensitiveStr::Ascii("ressos"), - dictgen::InsensitiveStr::Ascii("resss"), - dictgen::InsensitiveStr::Ascii("resssing"), - dictgen::InsensitiveStr::Ascii("resssion"), - dictgen::InsensitiveStr::Ascii("resssive"), - dictgen::InsensitiveStr::Ascii("ressus"), - dictgen::InsensitiveStr::Ascii("ressvie"), - dictgen::InsensitiveStr::Ascii("rom"), - dictgen::InsensitiveStr::Ascii("roms"), + 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")], + values: &[&["program"]], + range: 2..=2, +}; + +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("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: &[ - &["protagonists"], + &["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"], - &["progressed"], - &["prodigy"], + &["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("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"], &["programs"], &["procrastination"], - &["progressing"], - &["progression"], - &["progressions"], - &["progressive"], - &["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"], - &["progressing"], - &["progressions"], - &["progressives"], - &["progresses"], - &["progressives"], - &["pogrom"], - &["pogroms"], ], - range: 3..=12, + 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"), + ], + values: &[ + &["progressions"], + &["progressives"], + &["progress"], + &["progressbar"], + &["progressed"], + &["progresses"], + &["progressive"], + &["progressor"], + &["progress"], + ], + 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 { @@ -25276,6 +50479,7 @@ pub static WORD_PROF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("fesion"), dictgen::InsensitiveStr::Ascii("fesional"), dictgen::InsensitiveStr::Ascii("fesor"), + dictgen::InsensitiveStr::Ascii("fessor"), dictgen::InsensitiveStr::Ascii("iceint"), dictgen::InsensitiveStr::Ascii("iciancy"), dictgen::InsensitiveStr::Ascii("iciant"), @@ -25299,9 +50503,11 @@ pub static WORD_PROF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("itible"), dictgen::InsensitiveStr::Ascii("ressions"), dictgen::InsensitiveStr::Ascii("tiable"), + dictgen::InsensitiveStr::Ascii("und"), + dictgen::InsensitiveStr::Ascii("undly"), ], values: &[ - &["profusion"], + &["profusion", "profession"], &["profession"], &["professionals"], &["professor"], @@ -25335,6 +50541,7 @@ pub static WORD_PROF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["profession"], &["professional"], &["professor"], + &["professor"], &["proficient"], &["proficiency"], &["proficient"], @@ -25358,8 +50565,41 @@ pub static WORD_PROF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["profitable"], &["progressions"], &["profitable"], + &["profound"], + &["profoundly"], ], - range: 4..=12, + range: 3..=12, +}; + +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("jct"), + dictgen::InsensitiveStr::Ascii("jcted"), + dictgen::InsensitiveStr::Ascii("jcting"), + dictgen::InsensitiveStr::Ascii("jction"), + dictgen::InsensitiveStr::Ascii("prties"), + dictgen::InsensitiveStr::Ascii("prty"), + dictgen::InsensitiveStr::Ascii("rties"), + dictgen::InsensitiveStr::Ascii("rty"), + dictgen::InsensitiveStr::Ascii("ssing"), + ], + values: &[ + &["project"], + &["projected"], + &["projecting"], + &["projection"], + &["properties"], + &["property"], + &["properties"], + &["property", "poetry"], + &["processing"], + ], + range: 3..=6, }; static WORD_PROD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25369,6 +50609,7 @@ static WORD_PROD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -25377,13 +50618,17 @@ pub static WORD_PROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ecures"), 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"), @@ -25396,14 +50641,18 @@ pub static WORD_PROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ucto"), dictgen::InsensitiveStr::Ascii("uctoin"), dictgen::InsensitiveStr::Ascii("uctos"), + 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"], @@ -25412,13 +50661,17 @@ pub static WORD_PROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["procedures"], &["productions"], &["predominantly"], + &["producible"], + &["producibles"], &["production"], + &["produces", "produced"], &["produces"], &["producers"], &["produces"], &["producers"], &["production"], &["productions"], + &["produced"], &["productive"], &["productions"], &["production"], @@ -25431,10 +50684,13 @@ pub static WORD_PROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["production"], &["productions"], &["products"], + &["product"], &["production"], &["productions"], &["productive"], &["proudly"], + &["produces", "produce"], + &["produced"], &["produces"], &["productions"], ], @@ -25455,7 +50711,7 @@ static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_PROCI_NODE), None, None, Some(&WORD_PROCL_NODE), @@ -25466,7 +50722,7 @@ static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_PROCR_NODE), None, - None, + Some(&WORD_PROCT_NODE), Some(&WORD_PROCU_NODE), None, None, @@ -25481,9 +50737,36 @@ static WORD_PROCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_PROCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("dures")], - values: &[&["procedures"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("de"), + dictgen::InsensitiveStr::Ascii("ded"), + dictgen::InsensitiveStr::Ascii("dures"), + ], + values: &[&["produce"], &["produced"], &["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 { @@ -25538,11 +50821,21 @@ static WORD_PROCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["preconceived"], &["protocol"], &["protocols"]], + values: &[ + &["process"], + &["processed"], + &["processing"], + &["preconceived"], + &["protocol"], + &["protocols"], + ], range: 3..=7, }; @@ -25577,6 +50870,21 @@ pub static WORD_PROCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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::Flat(&WORD_PROCE_CHILDREN), value: None, @@ -25584,6 +50892,8 @@ static WORD_PROCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_PROCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cure"), + dictgen::InsensitiveStr::Ascii("cures"), dictgen::InsensitiveStr::Ascii("dding"), dictgen::InsensitiveStr::Ascii("ddings"), dictgen::InsensitiveStr::Ascii("de"), @@ -25594,6 +50904,8 @@ pub static WORD_PROCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("dger"), dictgen::InsensitiveStr::Ascii("ding"), dictgen::InsensitiveStr::Ascii("dings"), + dictgen::InsensitiveStr::Ascii("dre"), + dictgen::InsensitiveStr::Ascii("dres"), dictgen::InsensitiveStr::Ascii("drual"), dictgen::InsensitiveStr::Ascii("due"), dictgen::InsensitiveStr::Ascii("dureal"), @@ -25602,58 +50914,114 @@ pub static WORD_PROCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ededs"), dictgen::InsensitiveStr::Ascii("edes"), dictgen::InsensitiveStr::Ascii("edure"), + dictgen::InsensitiveStr::Ascii("edures"), dictgen::InsensitiveStr::Ascii("eed"), + dictgen::InsensitiveStr::Ascii("eeded"), + dictgen::InsensitiveStr::Ascii("eeding"), + dictgen::InsensitiveStr::Ascii("eeds"), + dictgen::InsensitiveStr::Ascii("eedures"), dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("esed"), dictgen::InsensitiveStr::Ascii("esing"), + dictgen::InsensitiveStr::Ascii("esor"), dictgen::InsensitiveStr::Ascii("lain"), + dictgen::InsensitiveStr::Ascii("lains"), + dictgen::InsensitiveStr::Ascii("ntual"), dictgen::InsensitiveStr::Ascii("s"), dictgen::InsensitiveStr::Ascii("sd"), dictgen::InsensitiveStr::Ascii("sed"), + dictgen::InsensitiveStr::Ascii("ses"), dictgen::InsensitiveStr::Ascii("sess"), + dictgen::InsensitiveStr::Ascii("shandler"), + dictgen::InsensitiveStr::Ascii("sing"), + dictgen::InsensitiveStr::Ascii("sor"), + dictgen::InsensitiveStr::Ascii("sseed"), + dictgen::InsensitiveStr::Ascii("ssees"), dictgen::InsensitiveStr::Ascii("sser"), dictgen::InsensitiveStr::Ascii("ssesor"), + dictgen::InsensitiveStr::Ascii("ssess"), + dictgen::InsensitiveStr::Ascii("ssessing"), dictgen::InsensitiveStr::Ascii("sseurs"), + dictgen::InsensitiveStr::Ascii("ssig"), + dictgen::InsensitiveStr::Ascii("ssinf"), + dictgen::InsensitiveStr::Ascii("ssore"), dictgen::InsensitiveStr::Ascii("ssos"), + dictgen::InsensitiveStr::Ascii("sspr"), dictgen::InsensitiveStr::Ascii("sss"), + dictgen::InsensitiveStr::Ascii("sssed"), + dictgen::InsensitiveStr::Ascii("ssses"), + dictgen::InsensitiveStr::Ascii("sssing"), dictgen::InsensitiveStr::Ascii("sssor"), dictgen::InsensitiveStr::Ascii("sssors"), + dictgen::InsensitiveStr::Ascii("sure"), + dictgen::InsensitiveStr::Ascii("sures"), ], values: &[ + &["procedure"], + &["procedures"], &["proceeding"], &["proceedings"], + &["proceed", "precede"], + &["proceeded", "preceded"], + &["procedure"], + &["procedural"], + &["proceeds", "precedes"], + &["procedure"], + &["proceeding", "preceding"], + &["proceedings"], + &["procedure"], + &["procedures"], + &["procedural"], + &["procedure"], + &["procedural"], + &["procedural"], + &["procedure"], + &["proceeds"], + &["proceeds"], + &["procedure"], + &["procedures"], &["proceed"], &["proceeded"], - &["procedure"], - &["procedural"], - &["proceeds"], - &["procedure"], &["proceeding"], - &["proceedings"], - &["procedural"], - &["procedure"], - &["procedural"], - &["procedural"], - &["procedure"], - &["proceeds"], - &["proceeds"], - &["procedure"], - &["proceed"], &["proceeds"], + &["procedures"], + &["proceeds", "process"], + &["processed"], &["proceeding"], + &["processor"], &["porcelain"], + &["porcelains"], + &["percentual"], &["process"], &["proceeds"], - &["proceeds"], + &["proceeds", "processed"], + &["processes"], + &["processes"], + &["processhandler"], + &["processing"], + &["processor"], + &["processed"], &["processes"], &["processor"], &["processors"], &["processes"], - &["processors"], + &["processing"], &["processes"], + &["processing"], + &["processing"], + &["processor"], + &["processors"], + &["processor"], + &["processes", "process"], + &["processed"], + &["processes"], + &["processing"], &["processors"], &["processors"], + &["procedure"], + &["procedures"], ], - range: 1..=6, + range: 1..=8, }; static WORD_PROCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25665,14 +51033,28 @@ pub static WORD_PROCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("eding"), dictgen::InsensitiveStr::Ascii("edings"), + dictgen::InsensitiveStr::Ascii("eed"), + 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"], + &["processor"], + &["processors"], &["process"], + &["processed"], + &["processes"], &["processing"], + &["processor"], + &["processors"], ], range: 3..=6, }; @@ -25707,6 +51089,7 @@ static WORD_PROB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("abaly"), dictgen::InsensitiveStr::Ascii("abe"), dictgen::InsensitiveStr::Ascii("abilaty"), dictgen::InsensitiveStr::Ascii("abiliste"), @@ -25720,20 +51103,43 @@ pub static WORD_PROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ablistic"), 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("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("limatic"), + dictgen::InsensitiveStr::Ascii("lme"), + dictgen::InsensitiveStr::Ascii("lmes"), dictgen::InsensitiveStr::Ascii("lomatic"), + dictgen::InsensitiveStr::Ascii("ly"), ], values: &[ + &["probably"], &["probable"], &["probability"], &["probabilities"], @@ -25742,25 +51148,47 @@ pub static WORD_PROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["probability"], &["probability"], &["probability"], - &["probability"], + &["probability", "probably"], &["probable"], &["probabilistic"], &["probably"], &["probable"], + &["probably"], + &["probably"], &["probability"], &["probably"], + &["probably"], + &["probabilities"], + &["probability"], + &["probably"], + &["probed"], + &["problem"], + &["problems"], + &["problem"], + &["problems"], + &["probably"], &["problem"], &["problematic"], &["problems"], + &["problem"], + &["properly"], + &["property", "properly"], + &["probably"], + &["problematic"], + &["probe"], + &["problem"], + &["problems"], &["problematic"], &["problem"], &["problems"], &["problematic"], &["problematic"], + &["problem"], + &["problems"], &["problematic"], - &["problematic"], + &["probably"], ], - range: 3..=9, + range: 2..=9, }; static WORD_PROA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25769,9 +51197,28 @@ static WORD_PROA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_PROA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ctivley")], - values: &[&["proactive"]], - range: 7..=7, + 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_PRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25797,9 +51244,9 @@ static WORD_PRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_PRIO_NODE), None, None, - None, + Some(&WORD_PRIR_NODE), Some(&WORD_PRIS_NODE), - None, + Some(&WORD_PRIT_NODE), None, Some(&WORD_PRIV_NODE), None, @@ -25820,6 +51267,9 @@ pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -25833,10 +51283,18 @@ pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -25845,11 +51303,18 @@ pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ilegier"), dictgen::InsensitiveStr::Ascii("ilegies"), dictgen::InsensitiveStr::Ascii("ilegs"), + 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("leges"), dictgen::InsensitiveStr::Ascii("te"), ], values: &[ @@ -25858,6 +51323,9 @@ pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["privileges"], &["privatized"], &["privatized"], + &["private"], + &["privacy"], + &["provide"], &["privileged"], &["privileges"], &["privileges"], @@ -25871,10 +51339,18 @@ pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["privileges"], &["privileges"], &["privatized"], + &["private"], + &["provide"], + &["provided"], + &["provides"], + &["providing"], + &["preview"], &["privilege"], &["privileged"], &["privileges"], &["privilege"], + &["privileged"], + &["privileges"], &["privileges"], &["privileges"], &["privilege"], @@ -25883,16 +51359,34 @@ pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["privilege"], &["privilege"], &["privileges"], + &["privilege"], &["privileged"], &["privileges"], + &["previous"], + &["previously"], + &["provision"], + &["provisional"], + &["provisions"], &["privatized"], &["privatized"], &["privilege"], + &["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: None, @@ -25907,6 +51401,17 @@ pub static WORD_PRIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ority")], + values: &[&["priority"]], + range: 5..=5, +}; + static WORD_PRIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PRIO_CHILDREN), value: None, @@ -25919,11 +51424,14 @@ pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ritice"), dictgen::InsensitiveStr::Ascii("ritie"), dictgen::InsensitiveStr::Ascii("ritied"), + dictgen::InsensitiveStr::Ascii("ritiy"), dictgen::InsensitiveStr::Ascii("ritse"), dictgen::InsensitiveStr::Ascii("roties"), dictgen::InsensitiveStr::Ascii("rotize"), + dictgen::InsensitiveStr::Ascii("rty"), dictgen::InsensitiveStr::Ascii("tities"), dictgen::InsensitiveStr::Ascii("titize"), + dictgen::InsensitiveStr::Ascii("tity"), ], values: &[ &["prioritize"], @@ -25931,13 +51439,16 @@ pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prioritize"], &["prioritize"], &["prioritize"], + &["priority"], &["priorities"], &["priorities"], &["prioritize"], + &["priority"], &["priorities"], &["prioritize"], + &["priority"], ], - range: 5..=6, + range: 3..=6, }; static WORD_PRIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -25948,6 +51459,8 @@ static WORD_PRIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -25967,15 +51480,23 @@ pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("terest"), dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("tting"), ], values: &[ &["principals"], + &["principle"], + &["principles"], &["princess"], &["princess"], &["princesses"], @@ -25995,14 +51516,20 @@ pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["principality"], &["principals"], &["principally"], + &["principle"], + &["print"], + &["print", "printf", "sprintf"], + &["print", "bring", "ping", "spring"], + &["printing", "springing"], &["principal"], &["principals"], &["principle"], &["principles"], &["printers"], &["printers"], + &["printing"], ], - range: 3..=8, + range: 1..=8, }; static WORD_PRIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26014,6 +51541,8 @@ pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -26021,11 +51550,19 @@ pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ative"), dictgen::InsensitiveStr::Ascii("atively"), dictgen::InsensitiveStr::Ascii("atives"), + dictgen::InsensitiveStr::Ascii("ay"), + dictgen::InsensitiveStr::Ascii("eter"), + dictgen::InsensitiveStr::Ascii("itiv"), + dictgen::InsensitiveStr::Ascii("itve"), + dictgen::InsensitiveStr::Ascii("itves"), + dictgen::InsensitiveStr::Ascii("ive"), dictgen::InsensitiveStr::Ascii("ordal"), ], values: &[ &["primaries"], &["primarily"], + &["primary"], + &["primarily"], &["primarily"], &["primaries"], &["primarily"], @@ -26033,9 +51570,15 @@ pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["primitive"], &["primitively"], &["primitives"], + &["primary"], + &["perimeter"], + &["primitive"], + &["primitive"], + &["primitives"], + &["primitive"], &["primordial"], ], - range: 4..=7, + range: 2..=7, }; static WORD_PRIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26069,8 +51612,16 @@ pub static WORD_PRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], ], - values: &[&["principals"], &["principal"], &["principle"]], range: 4..=6, }; @@ -26083,11 +51634,46 @@ pub static WORD_PRIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("sed"), dictgen::InsensitiveStr::Ascii("ses"), + dictgen::InsensitiveStr::Ascii("ve"), ], - values: &[&["praised"], &["praises"]], + 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"], + &["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, @@ -26095,7 +51681,7 @@ static WORD_PRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_PREA_NODE), - None, + Some(&WORD_PREB_NODE), Some(&WORD_PREC_NODE), Some(&WORD_PRED_NODE), Some(&WORD_PREE_NODE), @@ -26116,8 +51702,8 @@ static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_PRET_NODE), None, Some(&WORD_PREV_NODE), - None, - None, + Some(&WORD_PREW_NODE), + Some(&WORD_PREX_NODE), None, Some(&WORD_PREZ_NODE), ]; @@ -26133,6 +51719,31 @@ pub static WORD_PREZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -26146,10 +51757,18 @@ pub static WORD_PREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -26158,16 +51777,34 @@ pub static WORD_PREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ew"), + dictgen::InsensitiveStr::Ascii("ews"), dictgen::InsensitiveStr::Ascii("ial"), dictgen::InsensitiveStr::Ascii("ialing"), dictgen::InsensitiveStr::Ascii("ies"), + dictgen::InsensitiveStr::Ascii("iious"), + dictgen::InsensitiveStr::Ascii("ilege"), dictgen::InsensitiveStr::Ascii("ios"), + dictgen::InsensitiveStr::Ascii("iosly"), + dictgen::InsensitiveStr::Ascii("iosu"), dictgen::InsensitiveStr::Ascii("iosuly"), + dictgen::InsensitiveStr::Ascii("iou"), dictgen::InsensitiveStr::Ascii("ioulsy"), + dictgen::InsensitiveStr::Ascii("iouly"), + dictgen::InsensitiveStr::Ascii("iouse"), + dictgen::InsensitiveStr::Ascii("iousl"), + dictgen::InsensitiveStr::Ascii("isouly"), + 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"], @@ -26176,10 +51813,18 @@ pub static WORD_PREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prevalence"], &["preventative"], &["preview"], + &["previewed"], + &["previewer"], + &["previewers"], + &["previews", "previewers"], &["previews"], + &["prevalence"], &["prevalent"], + &["prevent"], &["prevention"], + &["prevent"], &["presentation"], + &["prevented", "prevent"], &["preventative"], &["prevention"], &["preventative"], @@ -26188,18 +51833,36 @@ pub static WORD_PREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["prevention"], &["prevents"], &["perverse"], + &["preserves"], &["pervert"], + &["preserve"], + &["preview"], + &["previews"], &["prevail"], &["prevailing"], &["previews"], &["previous"], + &["privilege"], + &["previous"], + &["previously"], + &["previous"], + &["previously"], + &["previous"], &["previously"], &["previously"], &["previous"], + &["previously"], + &["previously"], + &["previous"], + &["previous"], + &["previous"], &["previews"], + &["previous"], &["prevalence"], + &["previous"], + &["previously"], ], - range: 3..=8, + range: 2..=8, }; static WORD_PRET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26216,6 +51879,7 @@ pub static WORD_PRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -26236,6 +51900,7 @@ pub static WORD_PRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["pretentious"], &["pretends"], &["pretended"], + &["pretended"], &["pretends"], &["pretense"], &["pretends"], @@ -26255,7 +51920,7 @@ static WORD_PRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_PRESA_NODE), None, Some(&WORD_PRESC_NODE), None, @@ -26267,7 +51932,7 @@ static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_PRESM_NODE), Some(&WORD_PRESN_NODE), Some(&WORD_PRESO_NODE), Some(&WORD_PRESP_NODE), @@ -26298,7 +51963,9 @@ pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("de"), dictgen::InsensitiveStr::Ascii("mabely"), dictgen::InsensitiveStr::Ascii("mabley"), + dictgen::InsensitiveStr::Ascii("maby"), dictgen::InsensitiveStr::Ascii("mebly"), + dictgen::InsensitiveStr::Ascii("mely"), dictgen::InsensitiveStr::Ascii("mendo"), dictgen::InsensitiveStr::Ascii("mibly"), dictgen::InsensitiveStr::Ascii("mpteous"), @@ -26318,6 +51985,8 @@ pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["presumably"], &["presumably"], &["presumably"], + &["presumably"], + &["presumably"], &["presumed"], &["presumably"], &["presumptuous"], @@ -26376,11 +52045,26 @@ static WORD_PRESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("re"), + dictgen::InsensitiveStr::Ascii("s"), dictgen::InsensitiveStr::Ascii("uming"), dictgen::InsensitiveStr::Ascii("ureing"), ], - values: &[&["pressuring"], &["pressuring"]], - range: 5..=6, + values: &[ + &["pressed", "press"], + &["present"], + &["presentation"], + &["presented"], + &["pressure"], + &["press", "presses"], + &["pressuring"], + &["pressuring"], + ], + range: 1..=8, }; static WORD_PRESR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26389,9 +52073,12 @@ static WORD_PRESR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_PRESR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ciption")], - values: &[&["prescriptions"]], - range: 7..=7, + 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 { @@ -26437,8 +52124,23 @@ static WORD_PRESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_PRESN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("etation")], - values: &[&["presentations"]], + 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, }; @@ -26465,8 +52167,17 @@ pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -26489,8 +52200,17 @@ pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["presidents"], &["presidency"], &["persist"], + &["persistable"], &["persistence"], &["persistent"], + &["persistently"], + &["persisted"], + &["persistence"], + &["persistency"], + &["persistent"], + &["persistently"], + &["persisting"], + &["precision"], &["persists"], &["prestige"], &["prestigious"], @@ -26507,18 +52227,29 @@ static WORD_PRESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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"), @@ -26527,6 +52258,9 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -26536,8 +52270,22 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -26545,12 +52293,16 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["presidential"], &["presidents"], &["presidential"], + &["presence"], + &["presenter"], &["presenting"], &["presents"], &["presence"], &["presets"], &["presentation"], &["presentation"], + &["presentational"], + &["presentations"], &["presentations"], &["presents"], &["presents"], @@ -26559,6 +52311,9 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["presents"], &["presenting"], &["presents"], + &["present"], + &["preserved"], + &["preserve"], &["preservation"], &["preserve"], &["preservation"], @@ -26568,8 +52323,15 @@ pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["preserved"], &["preserved"], &["presets"], + &["presentation"], + &["preserve"], + &["preserved"], + &["perseverance"], + &["perseverance"], + &["preserves"], + &["preserving"], ], - range: 2..=7, + range: 2..=9, }; static WORD_PRESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26590,6 +52352,8 @@ pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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: &[ @@ -26604,11 +52368,24 @@ pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["prescriptions"], &["prescription"], &["prescriptions"], + &["prescription"], + &["prescriptions"], &["prescriptions"], ], range: 3..=11, }; +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, @@ -26617,27 +52394,41 @@ static WORD_PRER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PRER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("equesit"), + 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"], + &["prerequisites"], + &["prerequisite"], + &["prerequisite"], + &["prerequisite"], + &["prerequisites"], &["prerequisite"], &["prerequisite"], &["prerequisite"], &["prerequisite"], &["prerequisite"], - &["prerequisite"], + &["prerequisites"], &["period"], + &["periodic"], &["prerogative"], &["prerogative"], + &["persistent"], ], range: 3..=10, }; @@ -26650,10 +52441,11 @@ static WORD_PREQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PREQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("euls"), + dictgen::InsensitiveStr::Ascii("uisites"), dictgen::InsensitiveStr::Ascii("ules"), ], - values: &[&["prequels"], &["prequels"]], - range: 4..=4, + values: &[&["prequels"], &["prerequisites"], &["prequels"]], + range: 4..=7, }; static WORD_PREP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26665,11 +52457,18 @@ pub static WORD_PREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("air"), dictgen::InsensitiveStr::Ascii("aird"), + dictgen::InsensitiveStr::Ascii("aired"), + dictgen::InsensitiveStr::Ascii("and"), 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("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"), @@ -26680,21 +52479,41 @@ pub static WORD_PREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("resent"), + dictgen::InsensitiveStr::Ascii("resented"), + dictgen::InsensitiveStr::Ascii("resents"), + dictgen::InsensitiveStr::Ascii("roces"), + dictgen::InsensitiveStr::Ascii("rocesing"), + dictgen::InsensitiveStr::Ascii("rocesor"), + dictgen::InsensitiveStr::Ascii("rocesssing"), ], values: &[ &["prepare"], &["prepaid"], + &["prepared"], + &["prepend"], &["preparation"], &["preparation"], &["preparation"], + &["preparations"], + &["preparation"], + &["preparations"], &["preparatory"], + &["prepended"], &["perpendicular"], + &["prepended"], &["preparation"], &["preparations"], &["perpetrated"], @@ -26705,14 +52524,27 @@ pub static WORD_PREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["perpetuated"], &["perpetuates"], &["perpetuating"], + &["preponderance"], &["preparation"], &["preposterous"], &["preposterous"], &["preposterous"], &["preposterous"], &["preposterous"], + &["prepend"], + &["prepended"], + &["prepended"], + &["prepend", "preprent"], + &["prepended"], + &["represent"], + &["represented"], + &["represents"], + &["preprocess"], + &["preprocessing"], + &["preprocessor"], + &["preprocessing"], ], - range: 3..=9, + range: 3..=10, }; static WORD_PREO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26722,7 +52554,9 @@ static WORD_PREO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PREO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cess"), dictgen::InsensitiveStr::Ascii("cupation"), + dictgen::InsensitiveStr::Ascii("perty"), dictgen::InsensitiveStr::Ascii("rded"), dictgen::InsensitiveStr::Ascii("rderd"), dictgen::InsensitiveStr::Ascii("rderded"), @@ -26732,7 +52566,9 @@ pub static WORD_PREO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("xide"), ], values: &[ + &["process"], &["preoccupation"], + &["property"], &["preordered"], &["preordered"], &["preordered"], @@ -26772,9 +52608,13 @@ pub static WORD_PREM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), ], @@ -26800,13 +52640,17 @@ pub static WORD_PREM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["permissible"], &["permission"], &["permissions"], + &["permit"], &["permits"], &["premiums"], &["premonstratensians"], + &["preemption"], + &["preemptive"], + &["preemptively"], &["premium"], &["premiums"], ], - range: 3..=11, + range: 2..=11, }; static WORD_PREL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -26823,6 +52667,7 @@ pub static WORD_PREL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("imenary"), dictgen::InsensitiveStr::Ascii("imiary"), dictgen::InsensitiveStr::Ascii("iminarly"), + dictgen::InsensitiveStr::Ascii("imitary"), ], values: &[ &["replayed"], @@ -26832,6 +52677,7 @@ pub static WORD_PREL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["preliminary"], &["preliminary"], &["preliminary"], + &["preliminary"], ], range: 4..=9, }; @@ -26899,6 +52745,7 @@ pub static WORD_PREI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("sts"), dictgen::InsensitiveStr::Ascii("vew"), dictgen::InsensitiveStr::Ascii("vews"), + dictgen::InsensitiveStr::Ascii("vous"), ], values: &[ &["premier"], @@ -26920,6 +52767,7 @@ pub static WORD_PREI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["priests"], &["preview"], &["previews"], + &["previous"], ], range: 2..=12, }; @@ -26971,6 +52819,8 @@ pub static WORD_PREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("arable"), dictgen::InsensitiveStr::Ascii("arably"), + dictgen::InsensitiveStr::Ascii("ectches"), + dictgen::InsensitiveStr::Ascii("ecth"), dictgen::InsensitiveStr::Ascii("ection"), dictgen::InsensitiveStr::Ascii("ectly"), dictgen::InsensitiveStr::Ascii("erabbly"), @@ -26981,8 +52831,12 @@ pub static WORD_PREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("erances"), dictgen::InsensitiveStr::Ascii("erantial"), dictgen::InsensitiveStr::Ascii("eras"), + dictgen::InsensitiveStr::Ascii("ere"), dictgen::InsensitiveStr::Ascii("ereble"), + dictgen::InsensitiveStr::Ascii("erecne"), + dictgen::InsensitiveStr::Ascii("erecnes"), dictgen::InsensitiveStr::Ascii("ered"), + dictgen::InsensitiveStr::Ascii("erend"), dictgen::InsensitiveStr::Ascii("erens"), dictgen::InsensitiveStr::Ascii("erenser"), dictgen::InsensitiveStr::Ascii("erentail"), @@ -26995,11 +52849,23 @@ pub static WORD_PREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("eribly"), dictgen::InsensitiveStr::Ascii("ering"), dictgen::InsensitiveStr::Ascii("eris"), + dictgen::InsensitiveStr::Ascii("ernce"), + dictgen::InsensitiveStr::Ascii("ernces"), + dictgen::InsensitiveStr::Ascii("ernec"), dictgen::InsensitiveStr::Ascii("ernece"), + dictgen::InsensitiveStr::Ascii("err"), + dictgen::InsensitiveStr::Ascii("errable"), dictgen::InsensitiveStr::Ascii("errably"), + dictgen::InsensitiveStr::Ascii("errence"), + dictgen::InsensitiveStr::Ascii("errences"), dictgen::InsensitiveStr::Ascii("errring"), dictgen::InsensitiveStr::Ascii("errs"), dictgen::InsensitiveStr::Ascii("essionalism"), + dictgen::InsensitiveStr::Ascii("etchs"), + dictgen::InsensitiveStr::Ascii("ferable"), + dictgen::InsensitiveStr::Ascii("ferably"), + dictgen::InsensitiveStr::Ascii("fered"), + dictgen::InsensitiveStr::Ascii("ices"), dictgen::InsensitiveStr::Ascii("ormance"), dictgen::InsensitiveStr::Ascii("ormances"), dictgen::InsensitiveStr::Ascii("ormer"), @@ -27008,6 +52874,8 @@ pub static WORD_PREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["preferable"], &["preferably"], + &["prefetches"], + &["prefetch"], &["perfection"], &["perfectly"], &["preferably"], @@ -27018,8 +52886,12 @@ pub static WORD_PREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["preferences"], &["preferential"], &["prefers"], + &["prefer", "preferred"], &["preferable"], + &["preference"], + &["preferences"], &["preferred"], + &["preferred", "preference"], &["preferences"], &["preferences"], &["preferential"], @@ -27032,17 +52904,29 @@ pub static WORD_PREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["preferably"], &["preferring"], &["prefers"], + &["preference"], &["preferences"], + &["preference"], + &["preferences"], + &["prefer"], + &["preferable"], &["preferably"], + &["preference"], + &["preferences"], &["preferring"], &["prefers"], &["professionalism"], + &["prefetches"], + &["preferable"], + &["preferably"], + &["preferred"], + &["prefixes"], &["performance"], &["performances"], &["performer"], &["performers"], ], - range: 4..=11, + range: 3..=11, }; static WORD_PREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27051,9 +52935,14 @@ static WORD_PREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_PREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sts")], - values: &[&["presets"]], - range: 3..=3, + 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 { @@ -27189,6 +53078,7 @@ pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ctivo"), dictgen::InsensitiveStr::Ascii("ctment"), dictgen::InsensitiveStr::Ascii("ctons"), + dictgen::InsensitiveStr::Ascii("fined"), dictgen::InsensitiveStr::Ascii("sposte"), dictgen::InsensitiveStr::Ascii("termined"), ], @@ -27216,6 +53106,7 @@ pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["prediction"], &["predicament"], &["predictions"], + &["predefined"], &["predisposed"], &["predetermined"], ], @@ -27234,17 +53125,24 @@ pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("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"), @@ -27256,23 +53154,30 @@ pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["precedence"], &["predecessor"], &["predecessor"], + &["predecessors"], &["predecessor"], &["predecessors"], + &["predeclaring"], &["prediction"], &["predictions"], &["predictive"], + &["predefined"], + &["predefined"], + &["predefined"], + &["predefined"], &["predecessors"], &["predecessors"], &["predecessors"], &["predisposed"], &["predecessor"], &["predecessors"], + &["predecessor"], &["predetermined"], &["predetermined"], &["predetermined"], &["predetermined"], ], - range: 5..=9, + range: 4..=9, }; static WORD_PREDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27291,92 +53196,313 @@ pub static WORD_PREDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_PREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PREC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PREC_CHILDREN), value: None, }; -pub static WORD_PREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aucion"), - dictgen::InsensitiveStr::Ascii("ausion"), - dictgen::InsensitiveStr::Ascii("ausions"), - dictgen::InsensitiveStr::Ascii("autios"), - dictgen::InsensitiveStr::Ascii("edance"), - dictgen::InsensitiveStr::Ascii("edeed"), - dictgen::InsensitiveStr::Ascii("edense"), - dictgen::InsensitiveStr::Ascii("edessor"), - dictgen::InsensitiveStr::Ascii("edessors"), - dictgen::InsensitiveStr::Ascii("eed"), - dictgen::InsensitiveStr::Ascii("eeded"), - dictgen::InsensitiveStr::Ascii("eeding"), - dictgen::InsensitiveStr::Ascii("eeds"), - dictgen::InsensitiveStr::Ascii("eived"), - dictgen::InsensitiveStr::Ascii("endece"), - dictgen::InsensitiveStr::Ascii("endence"), - dictgen::InsensitiveStr::Ascii("entage"), - dictgen::InsensitiveStr::Ascii("entages"), - dictgen::InsensitiveStr::Ascii("entile"), - dictgen::InsensitiveStr::Ascii("ice"), - dictgen::InsensitiveStr::Ascii("iesly"), - dictgen::InsensitiveStr::Ascii("iselly"), - dictgen::InsensitiveStr::Ascii("isie"), - dictgen::InsensitiveStr::Ascii("isley"), - dictgen::InsensitiveStr::Ascii("isly"), - dictgen::InsensitiveStr::Ascii("isou"), - dictgen::InsensitiveStr::Ascii("onceieved"), - dictgen::InsensitiveStr::Ascii("onceved"), - dictgen::InsensitiveStr::Ascii("oncieve"), - dictgen::InsensitiveStr::Ascii("onveived"), - dictgen::InsensitiveStr::Ascii("rastination"), - dictgen::InsensitiveStr::Ascii("uation"), - dictgen::InsensitiveStr::Ascii("uations"), - dictgen::InsensitiveStr::Ascii("ulde"), - dictgen::InsensitiveStr::Ascii("urors"), - dictgen::InsensitiveStr::Ascii("urosr"), - dictgen::InsensitiveStr::Ascii("urser"), - dictgen::InsensitiveStr::Ascii("ussion"), + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("ations"), + dictgen::InsensitiveStr::Ascii("lde"), + dictgen::InsensitiveStr::Ascii("mputed"), + dictgen::InsensitiveStr::Ascii("rors"), + dictgen::InsensitiveStr::Ascii("rosr"), + dictgen::InsensitiveStr::Ascii("rser"), + dictgen::InsensitiveStr::Ascii("ssion"), ], values: &[ - &["precaution"], - &["precaution"], - &["precautions"], - &["precautions"], - &["precedence"], - &["preceded"], - &["precedence"], - &["predecessor"], - &["predecessors"], - &["precede"], - &["preceded"], - &["preceding"], - &["precedes"], - &["perceived"], - &["precedence"], - &["precedence"], - &["percentage"], - &["percentages"], - &["percentile"], - &["precise"], - &["precisely"], - &["precisely"], - &["precise"], - &["precisely"], - &["precisely"], - &["precious"], - &["preconceived"], - &["preconceived"], - &["preconceived"], - &["preconceived"], - &["procrastination"], - &["precautions"], + &["precautions", "precaution"], &["precautions"], &["preclude"], + &["precomputed"], &["precursor"], &["precursor"], &["precursor"], &["percussion"], ], - range: 3..=11, + 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("ions")], + values: &[&["precisions"]], + range: 4..=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("d"), + dictgen::InsensitiveStr::Ascii("dance"), + dictgen::InsensitiveStr::Ascii("deed"), + 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("ssor"), + ], + values: &[ + &["precede"], + &["precedence"], + &["preceded"], + &["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"], + &["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 { @@ -27388,11 +53514,67 @@ pub static WORD_PREA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["premade"], &["preamble"]], - range: 3..=5, + values: &[ + &["predator"], + &["predators"], + &["preallocating"], + &["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 { @@ -27401,9 +53583,29 @@ static WORD_PRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_PRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("eeded")], - values: &[&["preceded"]], - range: 5..=5, + keys: &[ + 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: &[ + &["preceded"], + &["process"], + &["processes"], + &["processing"], + &["process"], + &["processed"], + &["processes"], + &["processing"], + &["percentiles"], + ], + range: 3..=7, }; static WORD_PRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27413,6 +53615,8 @@ static WORD_PRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_PRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ameter"), + dictgen::InsensitiveStr::Ascii("ameters"), dictgen::InsensitiveStr::Ascii("citcal"), dictgen::InsensitiveStr::Ascii("citcally"), dictgen::InsensitiveStr::Ascii("citse"), @@ -27427,6 +53631,7 @@ pub static WORD_PRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("cticioners"), dictgen::InsensitiveStr::Ascii("cticlly"), dictgen::InsensitiveStr::Ascii("cticly"), + dictgen::InsensitiveStr::Ascii("cticval"), dictgen::InsensitiveStr::Ascii("ctie"), dictgen::InsensitiveStr::Ascii("cties"), dictgen::InsensitiveStr::Ascii("ctioner"), @@ -27438,21 +53643,30 @@ pub static WORD_PRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ctitionners"), dictgen::InsensitiveStr::Ascii("ctitions"), dictgen::InsensitiveStr::Ascii("ctives"), + 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("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"), ], values: &[ + &["parameter"], + &["parameters"], &["practical"], &["practically"], &["practise"], @@ -27467,6 +53681,7 @@ pub static WORD_PRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["practitioners"], &["practically"], &["practically"], + &["practical"], &["practise"], &["practise"], &["practitioner"], @@ -27478,15 +53693,22 @@ pub static WORD_PRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["practitioners"], &["practitioners"], &["practise"], + &["pragma"], &["pragmatic"], &["pragmatic"], &["prairie"], &["praises"], + &["parameter"], + &["parameter"], + &["parameters"], + &["parameter"], &["prairie"], &["prairies"], &["praised"], &["praises"], &["practise"], + &["practical"], + &["practically"], &["practice"], &["particle"], &["practitioners"], @@ -27501,9 +53723,12 @@ static WORD_PP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_PP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ublisher")], - values: &[&["publisher"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("olygons"), + dictgen::InsensitiveStr::Ascii("ublisher"), + ], + values: &[&["polygons"], &["publisher"]], + range: 7..=8, }; static WORD_PO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27513,20 +53738,20 @@ static WORD_PO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ None, - None, - None, + Some(&WORD_POB_NODE), + Some(&WORD_POC_NODE), Some(&WORD_POD_NODE), Some(&WORD_POE_NODE), None, - None, + Some(&WORD_POG_NODE), None, Some(&WORD_POI_NODE), - None, - None, + Some(&WORD_POJ_NODE), + Some(&WORD_POK_NODE), Some(&WORD_POL_NODE), Some(&WORD_POM_NODE), - None, - None, + Some(&WORD_PON_NODE), + Some(&WORD_POO_NODE), Some(&WORD_POP_NODE), None, Some(&WORD_POR_NODE), @@ -27578,6 +53803,7 @@ pub static WORD_POW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -27601,6 +53827,7 @@ pub static WORD_POW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["powerlifting"], &["powerlifting"], &["powerpoint"], + &["powerpc"], &["powerpoint"], &["powershell"], &["powerlifting"], @@ -27626,9 +53853,14 @@ static WORD_POU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_POU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lations")], - values: &[&["populations"]], - range: 7..=7, + keys: &[ + dictgen::InsensitiveStr::Ascii("lations"), + dictgen::InsensitiveStr::Ascii("nt"), + dictgen::InsensitiveStr::Ascii("nts"), + dictgen::InsensitiveStr::Ascii("pular"), + ], + values: &[&["populations"], &["point"], &["points"], &["popular"]], + range: 2..=7, }; static WORD_POT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27638,24 +53870,56 @@ static WORD_POT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], + &["position"], + &["protocol"], &["portrait"], &["portrayed"], ], - range: 4..=8, + range: 4..=11, }; static WORD_POS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27664,7 +53928,7 @@ static WORD_POS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_POSA_NODE), None, None, None, @@ -27679,7 +53943,7 @@ static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, - None, + Some(&WORD_POSP_NODE), None, None, Some(&WORD_POSS_NODE), @@ -27699,13 +53963,60 @@ static WORD_POST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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: &[&["potsdam"], &["posthumous"], &["position"], &["positive"]], - range: 3..=6, + values: &[ + &["postcondition"], + &["postconditions"], + &["potsdam"], + &["postgresql"], + &["postgresql"], + &["postgresql"], + &["posthumous"], + &["positional"], + &["positive"], + &["postincrement"], + &["position"], + &["positioned"], + &["positions"], + &["position"], + &["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 { @@ -27715,13 +54026,21 @@ static WORD_POSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"), @@ -27732,30 +54051,57 @@ pub static WORD_POSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("esss"), dictgen::InsensitiveStr::Ascii("esssion"), dictgen::InsensitiveStr::Ascii("estions"), + dictgen::InsensitiveStr::Ascii("iable"), + dictgen::InsensitiveStr::Ascii("ibbe"), + 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("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("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"], &["possibly"], + &["possible"], + &["possibly"], &["possesses"], &["possesses"], &["possessing"], &["possession"], &["possessive"], &["possessive"], + &["possessive"], &["possesses"], &["possesses"], &["possesses"], @@ -27765,20 +54111,54 @@ pub static WORD_POSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["possessions"], &["possessions"], &["possible"], + &["possible"], + &["possible"], + &["possible"], + &["possibilities"], + &["possibilities"], + &["possibilities"], &["possibility"], &["possibility"], + &["possibilities"], &["possibility"], - &["possibility"], + &["possibility", "possibly"], + &["possible"], + &["possible"], + &["possibly"], &["possibly"], &["possibility"], &["possibility"], &["possibilities"], + &["possibility"], &["possibly"], &["possibly"], + &["possible"], + &["possibly"], &["possessive"], &["position"], + &["positive"], + &["positives"], + &["possibly"], + &["possible"], + &["possibly"], + &["possible"], ], - range: 3..=8, + 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_POSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -27788,10 +54168,23 @@ static WORD_POSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"), @@ -27799,12 +54192,18 @@ pub static WORD_POSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("tiviely"), + dictgen::InsensitiveStr::Ascii("tivies"), dictgen::InsensitiveStr::Ascii("tivisme"), dictgen::InsensitiveStr::Ascii("tivisty"), dictgen::InsensitiveStr::Ascii("tivitely"), @@ -27814,14 +54213,34 @@ pub static WORD_POSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("tivley"), 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("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"], - &["poison"], - &["poisoned"], + &["positive"], + &["positives"], + &["positivity"], + &["poison", "psion"], + &["poisoned", "positioned"], + &["poisoning"], &["poisons"], + &["position"], + &["positioned"], + &["position"], &["positively"], &["positioning"], &["positioned"], @@ -27829,13 +54248,19 @@ pub static WORD_POSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["positional"], &["positional"], &["positional"], + &["position"], &["positional"], &["positioned"], &["positioned"], + &["positions"], &["positioning"], + &["positions"], + &["position"], + &["positive"], &["positivity"], &["positively"], &["positives"], + &["positives"], &["positivity"], &["positivity"], &["positivity"], @@ -27845,7 +54270,14 @@ pub static WORD_POSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["positives"], &["positivity"], &["position"], + &["positioned"], + &["positions"], + &["position", "positron"], + &["positioned"], + &["positioning"], + &["positions", "positrons"], &["positive"], + &["positives"], ], range: 2..=8, }; @@ -27857,6 +54289,7 @@ static WORD_POSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -27865,6 +54298,7 @@ pub static WORD_POSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ssions"), ], values: &[ + &["possessions"], &["possess"], &["possessed"], &["possesses"], @@ -27875,121 +54309,124 @@ pub static WORD_POSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic range: 2..=6, }; -static WORD_POR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_POR_CHILDREN), +static WORD_POSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_POSA_CHILDREN), value: None, }; -pub static WORD_POR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_POSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("alized"), - dictgen::InsensitiveStr::Ascii("celan"), - dictgen::InsensitiveStr::Ascii("celian"), - dictgen::InsensitiveStr::Ascii("celina"), - dictgen::InsensitiveStr::Ascii("eclain"), - dictgen::InsensitiveStr::Ascii("ftolio"), - dictgen::InsensitiveStr::Ascii("gramme"), - dictgen::InsensitiveStr::Ascii("jectiles"), - dictgen::InsensitiveStr::Ascii("letariat"), - dictgen::InsensitiveStr::Ascii("metheus"), - dictgen::InsensitiveStr::Ascii("nagraphy"), - dictgen::InsensitiveStr::Ascii("nograghy"), - dictgen::InsensitiveStr::Ascii("nograhpy"), - dictgen::InsensitiveStr::Ascii("nograhy"), - dictgen::InsensitiveStr::Ascii("nograpghy"), - dictgen::InsensitiveStr::Ascii("nograpgy"), - dictgen::InsensitiveStr::Ascii("nograpy"), - dictgen::InsensitiveStr::Ascii("nogrophy"), - dictgen::InsensitiveStr::Ascii("nogrpahy"), - dictgen::InsensitiveStr::Ascii("nogrphy"), - dictgen::InsensitiveStr::Ascii("portion"), - dictgen::InsensitiveStr::Ascii("portional"), - dictgen::InsensitiveStr::Ascii("portionally"), - dictgen::InsensitiveStr::Ascii("portions"), - dictgen::InsensitiveStr::Ascii("pose"), - dictgen::InsensitiveStr::Ascii("poses"), - dictgen::InsensitiveStr::Ascii("shan"), - dictgen::InsensitiveStr::Ascii("shon"), - dictgen::InsensitiveStr::Ascii("tabel"), - dictgen::InsensitiveStr::Ascii("tabillity"), - dictgen::InsensitiveStr::Ascii("tabilty"), - dictgen::InsensitiveStr::Ascii("tagonists"), - dictgen::InsensitiveStr::Ascii("tait"), - dictgen::InsensitiveStr::Ascii("talis"), - dictgen::InsensitiveStr::Ascii("talus"), - dictgen::InsensitiveStr::Ascii("tary"), - dictgen::InsensitiveStr::Ascii("tarying"), - dictgen::InsensitiveStr::Ascii("tayed"), - dictgen::InsensitiveStr::Ascii("testants"), - dictgen::InsensitiveStr::Ascii("tfoilo"), - dictgen::InsensitiveStr::Ascii("tgual"), - dictgen::InsensitiveStr::Ascii("toflio"), - dictgen::InsensitiveStr::Ascii("toguese"), - dictgen::InsensitiveStr::Ascii("traiing"), - dictgen::InsensitiveStr::Ascii("traing"), - dictgen::InsensitiveStr::Ascii("trais"), - dictgen::InsensitiveStr::Ascii("trary"), - dictgen::InsensitiveStr::Ascii("tras"), - dictgen::InsensitiveStr::Ascii("trat"), - dictgen::InsensitiveStr::Ascii("trating"), - dictgen::InsensitiveStr::Ascii("trayels"), - dictgen::InsensitiveStr::Ascii("trayes"), - dictgen::InsensitiveStr::Ascii("trayl"), - dictgen::InsensitiveStr::Ascii("trayls"), - dictgen::InsensitiveStr::Ascii("triat"), - dictgen::InsensitiveStr::Ascii("triats"), - dictgen::InsensitiveStr::Ascii("tugese"), - dictgen::InsensitiveStr::Ascii("tugeuse"), - dictgen::InsensitiveStr::Ascii("tuguease"), - dictgen::InsensitiveStr::Ascii("tugues"), - dictgen::InsensitiveStr::Ascii("tuguesse"), - dictgen::InsensitiveStr::Ascii("tuguise"), + 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), + None, + 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, + None, + None, + None, + None, + None, +]; + +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: &[ - &["polarized"], - &["porcelain"], - &["porcelain"], - &["porcelain"], - &["porcelain"], - &["portfolio"], - &["programme"], - &["projectiles"], - &["proletariat"], - &["prometheus"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["pornography"], - &["proportion"], - &["proportional"], - &["proportionally"], - &["proportions"], - &["propose"], - &["proposes"], - &["portion"], - &["portion"], &["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"], @@ -28009,7 +54446,253 @@ pub static WORD_POR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["portuguese"], &["portuguese"], ], - range: 4..=11, + 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("erty"), + dictgen::InsensitiveStr::Ascii("ortion"), + dictgen::InsensitiveStr::Ascii("ortional"), + dictgen::InsensitiveStr::Ascii("ortionally"), + dictgen::InsensitiveStr::Ascii("ortions"), + dictgen::InsensitiveStr::Ascii("ose"), + dictgen::InsensitiveStr::Ascii("oses"), + ], + values: &[ + &["property"], + &["proportion"], + &["proportional"], + &["proportionally"], + &["proportions"], + &["propose"], + &["proposes"], + ], + 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")], + values: &[&["peripheral"]], + range: 5..=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_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("lem"), + dictgen::InsensitiveStr::Ascii("lems"), + ], + values: &[&["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 { @@ -28019,11 +54702,24 @@ static WORD_POP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -28040,15 +54736,37 @@ pub static WORD_POP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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"], @@ -28065,10 +54783,71 @@ pub static WORD_POP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["populate"], &["populations"], &["popular"], + &["populate"], + &["populated"], &["populous"], &["populations"], + &["popular"], + &["popularity"], + &["populate"], + &["populated"], + &["populates"], + &["populating"], + &["population"], ], - range: 4..=9, + 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("inter"), + dictgen::InsensitiveStr::Ascii("iter"), + 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: &[ + &["pointer"], + &["pointer"], + &["point"], + &["potential"], + &["pointer"], + &["pointing"], + &["points"], + &["punctuation"], + ], + range: 1..=7, }; static WORD_POM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28080,74 +54859,207 @@ pub static WORD_POM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("egranite"), dictgen::InsensitiveStr::Ascii("otion"), + dictgen::InsensitiveStr::Ascii("pay"), ], - values: &[&["pomegranate"], &["promotion"]], - range: 5..=8, + values: &[&["pomegranate"], &["promotion"], &["pompeii"]], + range: 3..=8, }; static WORD_POL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_POL_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_POL_CHILDREN), value: None, }; -pub static WORD_POL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_POL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_POLA_NODE), + None, + None, + None, + None, + None, + Some(&WORD_POLG_NODE), + None, + Some(&WORD_POLI_NODE), + None, + None, + Some(&WORD_POLL_NODE), + None, + None, + Some(&WORD_POLO_NODE), + None, + 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("gyamy"), - dictgen::InsensitiveStr::Ascii("gyon"), - dictgen::InsensitiveStr::Ascii("ical"), - dictgen::InsensitiveStr::Ascii("icitally"), - dictgen::InsensitiveStr::Ascii("icitian"), - dictgen::InsensitiveStr::Ascii("icitians"), - dictgen::InsensitiveStr::Ascii("ietly"), - dictgen::InsensitiveStr::Ascii("inator"), - dictgen::InsensitiveStr::Ascii("inators"), - dictgen::InsensitiveStr::Ascii("ishees"), - dictgen::InsensitiveStr::Ascii("ishs"), - dictgen::InsensitiveStr::Ascii("ishuset"), - dictgen::InsensitiveStr::Ascii("isse"), - dictgen::InsensitiveStr::Ascii("itelly"), - dictgen::InsensitiveStr::Ascii("itessen"), - dictgen::InsensitiveStr::Ascii("itey"), - dictgen::InsensitiveStr::Ascii("iticain"), - dictgen::InsensitiveStr::Ascii("iticains"), - dictgen::InsensitiveStr::Ascii("iticaly"), - dictgen::InsensitiveStr::Ascii("itican"), - dictgen::InsensitiveStr::Ascii("iticanti"), - dictgen::InsensitiveStr::Ascii("iticas"), - dictgen::InsensitiveStr::Ascii("iticien"), - dictgen::InsensitiveStr::Ascii("iticiens"), - dictgen::InsensitiveStr::Ascii("iticin"), - dictgen::InsensitiveStr::Ascii("iticing"), - dictgen::InsensitiveStr::Ascii("iticion"), - dictgen::InsensitiveStr::Ascii("itickin"), - dictgen::InsensitiveStr::Ascii("iticus"), - dictgen::InsensitiveStr::Ascii("itiicans"), - dictgen::InsensitiveStr::Ascii("itiikan"), - dictgen::InsensitiveStr::Ascii("itiness"), - dictgen::InsensitiveStr::Ascii("iting"), - dictgen::InsensitiveStr::Ascii("ititian"), - dictgen::InsensitiveStr::Ascii("ititians"), - dictgen::InsensitiveStr::Ascii("itley"), - dictgen::InsensitiveStr::Ascii("tical"), - dictgen::InsensitiveStr::Ascii("ute"), - dictgen::InsensitiveStr::Ascii("uted"), - dictgen::InsensitiveStr::Ascii("utes"), - dictgen::InsensitiveStr::Ascii("uting"), - dictgen::InsensitiveStr::Ascii("ution"), - dictgen::InsensitiveStr::Ascii("ygammy"), - dictgen::InsensitiveStr::Ascii("ygoon"), - dictgen::InsensitiveStr::Ascii("ymore"), - dictgen::InsensitiveStr::Ascii("yphonyic"), - dictgen::InsensitiveStr::Ascii("ysaccaride"), + 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("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"], + &["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("te"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("ting"), + dictgen::InsensitiveStr::Ascii("tion"), + ], + values: &[ + &["pollute"], + &["polluted"], + &["pollutes"], + &["polluting"], + &["pollution"], + ], + range: 2..=4, +}; + +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("ical"), + dictgen::InsensitiveStr::Ascii("ry"), + ], + values: &[&["political"], &["poultry"]], + range: 2..=4, +}; + +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("gon"), + dictgen::InsensitiveStr::Ascii("gons"), + ], + values: &[&["polygon"], &["polygons"]], + range: 3..=4, +}; + +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("cie"), + dictgen::InsensitiveStr::Ascii("citally"), + dictgen::InsensitiveStr::Ascii("citian"), + dictgen::InsensitiveStr::Ascii("citians"), + 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"], + &["policies", "policy", "police"], &["politically"], &["politician"], &["politicians"], &["politely"], + &["polygon"], + &["polygons"], &["pollinator"], &["pollinators"], &["polishes"], @@ -28161,12 +55073,13 @@ pub static WORD_POL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["politicians"], &["politically"], &["politician"], + &["politicians"], &["politician"], &["politics"], &["politician"], &["politicians"], &["politician"], - &["politician"], + &["politician", "politicking"], &["politician"], &["politician"], &["politics"], @@ -28177,19 +55090,59 @@ pub static WORD_POL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["politician"], &["politicians"], &["politely"], - &["political"], - &["pollute"], - &["polluted"], - &["pollutes"], - &["polluting"], - &["pollution"], - &["polygamy"], - &["polygon"], - &["polymer"], - &["polyphonic"], - &["polysaccharide"], ], - range: 3..=10, + 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("yamy"), + dictgen::InsensitiveStr::Ascii("yon"), + ], + values: &[&["polygamy"], &["polygon"]], + range: 3..=4, +}; + +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"), + ], + values: &[&["project"], &["projecting"], &["point"]], + range: 2..=6, }; static WORD_POI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28199,36 +55152,111 @@ static WORD_POI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("t"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("ters"), + dictgen::InsensitiveStr::Ascii("tn"), + dictgen::InsensitiveStr::Ascii("tner"), + dictgen::InsensitiveStr::Ascii("tning"), + dictgen::InsensitiveStr::Ascii("ts"), + dictgen::InsensitiveStr::Ascii("unter"), ], values: &[ + &["policies"], + &["policy"], &["poignant"], + &["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"], + &["point"], + &["pointer"], + &["pointers"], + &["point"], + &["pointer"], + &["pointing"], + &["points"], + &["pointer"], ], - range: 3..=6, + 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 { @@ -28239,12 +55267,27 @@ static WORD_POE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ty"), ], - values: &[&["penis"], &["peoples"], &["peoples"], &["poetry"]], - range: 2..=5, + values: &[ + &["penis"], + &["potential"], + &["potentially"], + &["potentials"], + &["peoples"], + &["people"], + &["peoples"], + &["power"], + &["poetry"], + ], + range: 1..=7, }; static WORD_POD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28256,9 +55299,43 @@ pub static WORD_POD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("emso"), dictgen::InsensitiveStr::Ascii("meos"), + dictgen::InsensitiveStr::Ascii("ule"), ], - values: &[&["podemos"], &["podemos"]], - range: 4..=4, + values: &[&["podemos"], &["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 { @@ -28289,7 +55366,7 @@ static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_PLI_NODE), None, None, - None, + Some(&WORD_PLL_NODE), None, None, Some(&WORD_PLO_NODE), @@ -28297,15 +55374,65 @@ static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, + Some(&WORD_PLT_NODE), + Some(&WORD_PLU_NODE), None, None, None, - 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("ging"), + dictgen::InsensitiveStr::Ascii("ign"), + dictgen::InsensitiveStr::Ascii("igns"), + dictgen::InsensitiveStr::Ascii("se"), + ], + values: &[ + &["pluggable"], + &["plugged"], + &["plugging", "plugin"], + &["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, @@ -28315,6 +55442,7 @@ pub static WORD_PLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("arized"), dictgen::InsensitiveStr::Ascii("retariat"), + dictgen::InsensitiveStr::Ascii("ting"), dictgen::InsensitiveStr::Ascii("ygamy"), dictgen::InsensitiveStr::Ascii("ygon"), dictgen::InsensitiveStr::Ascii("ymer"), @@ -28322,6 +55450,7 @@ pub static WORD_PLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["polarized"], &["proletariat"], + &["plotting"], &["polygamy"], &["polygon"], &["polymer"], @@ -28329,15 +55458,29 @@ pub static WORD_PLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 4..=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("grim")], - values: &[&["pilgrim"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("an"), + dictgen::InsensitiveStr::Ascii("grim"), + ], + values: &[&["plain", "pliant"], &["pilgrim"]], + range: 2..=4, }; static WORD_PLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28347,26 +55490,56 @@ static WORD_PLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 4..=7, + range: 2..=7, }; static WORD_PLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28380,13 +55553,13 @@ static WORD_PLA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_PLAC_NODE), None, Some(&WORD_PLAE_NODE), - None, + Some(&WORD_PLAF_NODE), Some(&WORD_PLAG_NODE), None, Some(&WORD_PLAI_NODE), None, None, - None, + Some(&WORD_PLAL_NODE), None, Some(&WORD_PLAN_NODE), None, @@ -28412,8 +55585,13 @@ pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("groud"), dictgen::InsensitiveStr::Ascii("htrough"), @@ -28446,8 +55624,13 @@ pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["playable"], &["playground"], + &["playable"], &["playboy"], &["playerbase"], + &["playful", "playfully"], + &["plague"], + &["plagiarise"], + &["plagiarize"], &["playground"], &["playground"], &["playthrough"], @@ -28477,7 +55660,7 @@ pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["playwright"], &["playwrights"], ], - range: 3..=10, + range: 2..=10, }; static WORD_PLAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28487,6 +55670,7 @@ static WORD_PLAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -28494,6 +55678,7 @@ pub static WORD_PLAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("throughs"), ], values: &[ + &["plausibility"], &["plausible"], &["plausible"], &["plausible"], @@ -28513,37 +55698,77 @@ pub static WORD_PLAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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("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("tform"), + dictgen::InsensitiveStr::Ascii("tforms"), ], values: &[ &["plateau"], &["plateau"], &["plateau"], + &["platform"], + &["platformer"], + &["platforms"], + &["platform"], + &["platforms"], + &["platform"], + &["platforms"], + &["platform"], + &["platform"], + &["platforms"], &["platformer"], &["platformer"], - &["platformer"], + &["platforms"], &["platformer"], &["platform"], &["platformer"], &["platformer"], &["platforms"], + &["platform"], &["platinum"], &["platinum"], &["platinum"], + &["platform"], + &["platforms"], + &["platforms"], + &["platforms"], + &["platform"], + &["platforms"], + &["platform"], &["platformer"], &["platforms"], + &["platform"], + &["platforms"], ], range: 2..=7, }; @@ -28555,6 +55780,12 @@ static WORD_PLAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -28564,6 +55795,12 @@ pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("tre"), ], values: &[ + &["place", "please", "phase", "plaice"], + &["placed", "pleased", "phased"], + &["placement"], + &["placements"], + &["places", "pleases", "phases"], + &["placing", "pleasing", "phasing"], &["plastics"], &["plastics"], &["plastics"], @@ -28572,7 +55809,7 @@ pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["plastics"], &["plaster"], ], - range: 3..=6, + range: 1..=6, }; static WORD_PLAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28597,6 +55834,7 @@ pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("sewalkers"), dictgen::InsensitiveStr::Ascii("teary"), dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("text"), dictgen::InsensitiveStr::Ascii("tiff"), dictgen::InsensitiveStr::Ascii("tium"), ], @@ -28616,12 +55854,27 @@ pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["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, @@ -28666,6 +55919,22 @@ pub static WORD_PLAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -28689,25 +55958,49 @@ static WORD_PLAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"], + &["placemat", "placement"], + &["placements", "placement"], &["placements"], &["placements"], + &["placements", "placement", "placemat"], + &["placements", "placemats"], + &["placeholder"], + &["placeholders"], + &["placement"], &["placements"], ], - range: 4..=6, + range: 4..=7, }; static WORD_PLAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28733,77 +56026,205 @@ pub static WORD_PK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg }; static WORD_PI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PI_CHILDREN), value: None, }; -pub static WORD_PI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("ankillers"), - dictgen::InsensitiveStr::Ascii("blisher"), - dictgen::InsensitiveStr::Ascii("ch"), - dictgen::InsensitiveStr::Ascii("cthed"), - dictgen::InsensitiveStr::Ascii("cther"), - dictgen::InsensitiveStr::Ascii("cthers"), - dictgen::InsensitiveStr::Ascii("cthes"), - dictgen::InsensitiveStr::Ascii("cthfork"), - dictgen::InsensitiveStr::Ascii("cthforks"), - dictgen::InsensitiveStr::Ascii("egons"), - dictgen::InsensitiveStr::Ascii("glrim"), - dictgen::InsensitiveStr::Ascii("goens"), - dictgen::InsensitiveStr::Ascii("lgirm"), - dictgen::InsensitiveStr::Ascii("lgrimmage"), - dictgen::InsensitiveStr::Ascii("lgrimmages"), - dictgen::InsensitiveStr::Ascii("llards"), - dictgen::InsensitiveStr::Ascii("llaris"), - dictgen::InsensitiveStr::Ascii("lrgim"), - dictgen::InsensitiveStr::Ascii("nancle"), - dictgen::InsensitiveStr::Ascii("napple"), - dictgen::InsensitiveStr::Ascii("netrest"), - dictgen::InsensitiveStr::Ascii("nnalce"), - dictgen::InsensitiveStr::Ascii("nnaple"), - dictgen::InsensitiveStr::Ascii("nncale"), - dictgen::InsensitiveStr::Ascii("noeer"), - dictgen::InsensitiveStr::Ascii("noneered"), - dictgen::InsensitiveStr::Ascii("npiont"), - dictgen::InsensitiveStr::Ascii("npoit"), - dictgen::InsensitiveStr::Ascii("nteret"), - dictgen::InsensitiveStr::Ascii("olting"), - dictgen::InsensitiveStr::Ascii("oneeer"), - dictgen::InsensitiveStr::Ascii("onere"), - dictgen::InsensitiveStr::Ascii("reced"), - dictgen::InsensitiveStr::Ascii("tchferks"), - dictgen::InsensitiveStr::Ascii("tchfolks"), - dictgen::InsensitiveStr::Ascii("tchforcks"), - dictgen::InsensitiveStr::Ascii("tchfords"), - dictgen::InsensitiveStr::Ascii("tchforkers"), - dictgen::InsensitiveStr::Ascii("tchforkes"), - dictgen::InsensitiveStr::Ascii("tchworks"), - dictgen::InsensitiveStr::Ascii("tckforks"), - dictgen::InsensitiveStr::Ascii("thcers"), - dictgen::InsensitiveStr::Ascii("thces"), - dictgen::InsensitiveStr::Ascii("ttaburgh"), - dictgen::InsensitiveStr::Ascii("ttsbrugh"), + 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: &[ - &["painkillers"], - &["publisher"], - &["pitch"], - &["pitched"], - &["pitcher"], + &["pitchforks"], + &["pitchforks"], + &["pitchforks"], + &["pitchforks"], + &["pitchforks"], + &["pitchforks"], + &["pitchforks"], + &["pitchforks"], &["pitchers"], &["pitches"], - &["pitchfork"], - &["pitchforks"], - &["pigeons"], - &["pilgrim"], - &["pigeons"], - &["pilgrim"], - &["pilgrimage"], - &["pilgrimages"], - &["pillars"], - &["pillars"], - &["pilgrim"], + &["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")], + values: &[&["pierced"]], + range: 4..=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("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"), + ], + values: &[ + &["pipeline"], + &["pipelines"], + &["pipeline"], + &["pipelining"], + &["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("etrest"), + dictgen::InsensitiveStr::Ascii("nalce"), + dictgen::InsensitiveStr::Ascii("naple"), + dictgen::InsensitiveStr::Ascii("ncale"), + dictgen::InsensitiveStr::Ascii("oeer"), + dictgen::InsensitiveStr::Ascii("oneered"), + dictgen::InsensitiveStr::Ascii("piont"), + dictgen::InsensitiveStr::Ascii("poit"), + dictgen::InsensitiveStr::Ascii("teret"), + ], + values: &[ &["pinnacle"], &["pineapple"], &["pinterest"], @@ -28815,24 +56236,130 @@ pub static WORD_PI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["pinpoint"], &["pinpoint"], &["pinterest"], - &["piloting"], - &["pioneer"], - &["pioneer"], - &["pierced"], - &["pitchforks"], - &["pitchforks"], - &["pitchforks"], - &["pitchforks"], - &["pitchforks"], - &["pitchforks"], - &["pitchforks"], - &["pitchforks"], + ], + range: 4..=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("grimmage"), + dictgen::InsensitiveStr::Ascii("grimmages"), + dictgen::InsensitiveStr::Ascii("lards"), + dictgen::InsensitiveStr::Ascii("laris"), + dictgen::InsensitiveStr::Ascii("rgim"), + ], + values: &[ + &["pilgrim"], + &["pilgrimage"], + &["pilgrimages"], + &["pillars"], + &["pillars"], + &["pilgrim"], + ], + range: 4..=9, +}; + +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("lrim"), + dictgen::InsensitiveStr::Ascii("oens"), + ], + values: &[&["pilgrim"], &["pigeons"]], + range: 4..=4, +}; + +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("h"), + 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"), + ], + values: &[ + &["pitch"], + &["picosecond"], + &["picoseconds"], + &["pitched"], + &["pitcher"], &["pitchers"], &["pitches"], - &["pittsburgh"], - &["pittsburgh"], + &["pitchfork"], + &["pitchforks"], ], - range: 2..=10, + range: 1..=7, +}; + +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")], + values: &[&["painkillers"]], + range: 8..=8, }; static WORD_PH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -28860,7 +56387,7 @@ static WORD_PH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_PHR_NODE), Some(&WORD_PHS_NODE), - None, + Some(&WORD_PHT_NODE), None, None, None, @@ -28911,6 +56438,7 @@ pub static WORD_PHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("sicials"), @@ -28924,7 +56452,10 @@ pub static WORD_PHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("siologial"), dictgen::InsensitiveStr::Ascii("siqe"), dictgen::InsensitiveStr::Ascii("sisict"), + dictgen::InsensitiveStr::Ascii("sisist"), dictgen::InsensitiveStr::Ascii("sqiue"), + dictgen::InsensitiveStr::Ascii("thon"), + dictgen::InsensitiveStr::Ascii("ton"), ], values: &[ &["psychedelics"], @@ -28962,6 +56493,7 @@ pub static WORD_PHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["psychopath"], &["psychopathic"], &["psychopaths"], + &["physical"], &["physically"], &["physically"], &["physicians"], @@ -28975,9 +56507,26 @@ pub static WORD_PHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["physiological"], &["physique"], &["physicist"], + &["physicist"], &["physique"], + &["python"], + &["python"], ], - range: 4..=12, + 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 { @@ -29039,10 +56588,15 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -29062,6 +56616,7 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -29084,10 +56639,15 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["phoenecian"], &["phenomena"], + &["phonetically"], &["phonograph"], &["photographer"], &["photographers"], + &["photo"], &["photoshopped"], + &["photographic"], + &["photographical"], + &["photography"], &["photograph"], &["photograph"], &["photographed"], @@ -29107,6 +56667,7 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["photographer"], &["photographic"], &["photographic"], + &["photographical"], &["photographed"], &["photographs"], &["photography"], @@ -29126,79 +56687,125 @@ pub static WORD_PHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["photoshopped"], &["photoshopped"], ], - range: 6..=10, + range: 2..=10, }; static WORD_PHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PHI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PHI_CHILDREN), value: None, }; -pub static WORD_PHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aldelphia"), - dictgen::InsensitiveStr::Ascii("ladalphia"), - dictgen::InsensitiveStr::Ascii("ladelhpia"), - dictgen::InsensitiveStr::Ascii("ladelpha"), - dictgen::InsensitiveStr::Ascii("ladelpia"), - dictgen::InsensitiveStr::Ascii("ladeplhia"), - dictgen::InsensitiveStr::Ascii("ladlephia"), - dictgen::InsensitiveStr::Ascii("ledalphia"), - dictgen::InsensitiveStr::Ascii("ledelphia"), - dictgen::InsensitiveStr::Ascii("lidalphia"), - dictgen::InsensitiveStr::Ascii("liphines"), + dictgen::InsensitiveStr::Ascii("iological"), + dictgen::InsensitiveStr::Ascii("osophy"), + ], + values: &[&["physiological"], &["philosophy"]], + range: 6..=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("lippenes"), - dictgen::InsensitiveStr::Ascii("lippenis"), - dictgen::InsensitiveStr::Ascii("lippides"), - dictgen::InsensitiveStr::Ascii("lippinas"), - dictgen::InsensitiveStr::Ascii("lippinnes"), - dictgen::InsensitiveStr::Ascii("lippinoes"), - dictgen::InsensitiveStr::Ascii("lippinos"), - dictgen::InsensitiveStr::Ascii("lippins"), - dictgen::InsensitiveStr::Ascii("lisopher"), - dictgen::InsensitiveStr::Ascii("lisophers"), - dictgen::InsensitiveStr::Ascii("lisophical"), - dictgen::InsensitiveStr::Ascii("lisophies"), - dictgen::InsensitiveStr::Ascii("lisophy"), - dictgen::InsensitiveStr::Ascii("llipine"), - dictgen::InsensitiveStr::Ascii("llipines"), - dictgen::InsensitiveStr::Ascii("llippines"), - dictgen::InsensitiveStr::Ascii("llipse"), - dictgen::InsensitiveStr::Ascii("llipses"), - dictgen::InsensitiveStr::Ascii("llosophically"), - dictgen::InsensitiveStr::Ascii("loshopically"), - dictgen::InsensitiveStr::Ascii("losipher"), - dictgen::InsensitiveStr::Ascii("losiphers"), - dictgen::InsensitiveStr::Ascii("losiphical"), - dictgen::InsensitiveStr::Ascii("losiphies"), - dictgen::InsensitiveStr::Ascii("losiphy"), - dictgen::InsensitiveStr::Ascii("losohpers"), - dictgen::InsensitiveStr::Ascii("losohpical"), - dictgen::InsensitiveStr::Ascii("losohpically"), - dictgen::InsensitiveStr::Ascii("losohpies"), - dictgen::InsensitiveStr::Ascii("losohpy"), - dictgen::InsensitiveStr::Ascii("losoper"), - dictgen::InsensitiveStr::Ascii("losopers"), - dictgen::InsensitiveStr::Ascii("losophae"), - dictgen::InsensitiveStr::Ascii("losophia"), - dictgen::InsensitiveStr::Ascii("losophiae"), - dictgen::InsensitiveStr::Ascii("losophicaly"), - dictgen::InsensitiveStr::Ascii("losophics"), - dictgen::InsensitiveStr::Ascii("losophios"), - dictgen::InsensitiveStr::Ascii("losophycal"), - dictgen::InsensitiveStr::Ascii("losophycally"), - dictgen::InsensitiveStr::Ascii("losopies"), - dictgen::InsensitiveStr::Ascii("losopy"), - dictgen::InsensitiveStr::Ascii("lospher"), - dictgen::InsensitiveStr::Ascii("losphies"), - dictgen::InsensitiveStr::Ascii("losphy"), - dictgen::InsensitiveStr::Ascii("lospoher"), - dictgen::InsensitiveStr::Ascii("lospohers"), - dictgen::InsensitiveStr::Ascii("lospohical"), - dictgen::InsensitiveStr::Ascii("lospohies"), - dictgen::InsensitiveStr::Ascii("lospohy"), - dictgen::InsensitiveStr::Ascii("siological"), + 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"], @@ -29210,7 +56817,6 @@ pub static WORD_PHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["philadelphia"], &["philadelphia"], &["philadelphia"], - &["philadelphia"], &["philippines"], &["philippines"], &["philippines"], @@ -29263,9 +56869,19 @@ pub static WORD_PHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["philosophical"], &["philosophies"], &["philosophy"], - &["physiological"], ], - range: 6..=13, + 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 { @@ -29299,6 +56915,7 @@ pub static WORD_PHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nonemal"), dictgen::InsensitiveStr::Ascii("nonemon"), dictgen::InsensitiveStr::Ascii("nonmena"), + dictgen::InsensitiveStr::Ascii("riparials"), ], values: &[ &["phenomena"], @@ -29325,6 +56942,7 @@ pub static WORD_PHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["phenomenal"], &["phenomenon"], &["phenomena"], + &["peripherals"], ], range: 5..=9, }; @@ -29355,6 +56973,8 @@ pub static WORD_PHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rmicist"), dictgen::InsensitiveStr::Ascii("rmsci"), dictgen::InsensitiveStr::Ascii("roah"), + dictgen::InsensitiveStr::Ascii("sepsace"), + dictgen::InsensitiveStr::Ascii("sis"), dictgen::InsensitiveStr::Ascii("tnom"), ], values: &[ @@ -29377,9 +56997,11 @@ pub static WORD_PHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["pharmacist"], &["pharmacist"], &["pharaoh"], + &["phasespace"], + &["phases"], &["phantom"], ], - range: 4..=12, + range: 3..=12, }; static WORD_PE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -29394,12 +57016,12 @@ static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_PED_NODE), None, Some(&WORD_PEF_NODE), - None, + Some(&WORD_PEG_NODE), None, Some(&WORD_PEI_NODE), None, None, - None, + Some(&WORD_PEL_NODE), None, Some(&WORD_PEN_NODE), Some(&WORD_PEO_NODE), @@ -29409,13 +57031,38 @@ static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_PES_NODE), Some(&WORD_PET_NODE), None, + Some(&WORD_PEV_NODE), None, None, None, - 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_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, @@ -29537,6 +57184,7 @@ pub static WORD_PERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("iew"), dictgen::InsensitiveStr::Ascii("iews"), dictgen::InsensitiveStr::Ascii("ious"), + dictgen::InsensitiveStr::Ascii("iously"), ], values: &[ &["prevail"], @@ -29550,6 +57198,7 @@ pub static WORD_PERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["preview"], &["previews"], &["previous"], + &["previously"], ], range: 3..=6, }; @@ -29579,8 +57228,19 @@ pub static WORD_PERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("inante"), 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"), ], values: &[ &["pertaining"], @@ -29590,10 +57250,21 @@ pub static WORD_PERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["pertinent"], &["pertinent"], &["petroleum"], + &["perturb"], &["perturbation"], &["perturbations"], + &["perturbing"], + &["perturb"], + &["perturb"], + &["perturbed"], + &["perturbs"], + &["perturbation"], + &["perturbations"], + &["perturbing"], + &["perturb"], + &["perturbs"], ], - range: 4..=8, + range: 2..=9, }; static WORD_PERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -29758,8 +57429,10 @@ pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("nalitys"), dictgen::InsensitiveStr::Ascii("nallity"), dictgen::InsensitiveStr::Ascii("naly"), dictgen::InsensitiveStr::Ascii("narse"), @@ -29771,6 +57444,7 @@ pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("nhoood"), dictgen::InsensitiveStr::Ascii("nilized"), dictgen::InsensitiveStr::Ascii("nis"), + dictgen::InsensitiveStr::Ascii("nnal"), dictgen::InsensitiveStr::Ascii("nnell"), dictgen::InsensitiveStr::Ascii("nsa"), ], @@ -29781,19 +57455,22 @@ pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["personalized"], &["personas"], &["personalities"], + &["personality"], + &["personalities"], &["personalities"], &["personalities"], &["personally"], &["personally"], &["personas"], &["personas"], - &["personnel"], + &["personnel", "personal"], &["personnel"], &["persons"], &["personhood"], &["personhood"], &["personalized"], &["persons"], + &["personal"], &["personnel"], &["personas"], ], @@ -29810,29 +57487,39 @@ pub static WORD_PERSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("ts"), ], values: &[ &["persecuted"], &["persecution"], &["persist"], + &["persisted"], &["persistence"], &["persistent"], &["persistent"], + &["persistently"], + &["persistent"], &["persists"], &["persistence"], &["persistence"], + &["persisted"], &["persists"], + &["persisted"], &["persist"], ], - range: 2..=6, + range: 2..=7, }; static WORD_PERSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -29852,9 +57539,13 @@ pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("cutted"), 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("rves"), dictgen::InsensitiveStr::Ascii("rving"), dictgen::InsensitiveStr::Ascii("ts"), dictgen::InsensitiveStr::Ascii("verence"), @@ -29870,14 +57561,18 @@ pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["persecuted"], &["perspective"], &["perspectives"], + &["perspective"], + &["perspectives"], &["preservation"], &["preserve"], &["preserved"], + &["perseverance"], + &["preserves"], &["preserving"], &["presets"], &["perseverance"], ], - range: 2..=7, + range: 2..=8, }; static WORD_PERSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -29925,9 +57620,12 @@ static WORD_PERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_PERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ogative")], - values: &[&["prerogative"]], - range: 7..=7, + 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 { @@ -29954,7 +57652,9 @@ pub static WORD_PERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -30009,7 +57709,9 @@ pub static WORD_PERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["perpetuated"], &["perpetrators"], &["perpetrators"], + &["properties"], &["perpetrated"], + &["property"], &["perpetrated"], &["perpetrator"], &["perpetrator"], @@ -30056,28 +57758,34 @@ static WORD_PERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("endicular"), dictgen::InsensitiveStr::Ascii("gative"), + dictgen::InsensitiveStr::Ascii("id"), dictgen::InsensitiveStr::Ascii("idic"), dictgen::InsensitiveStr::Ascii("idically"), 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: &[ + &["perpendicular"], &["prerogative"], + &["period"], &["periodic"], &["periodically"], &["periods"], &["personal"], + &["properly"], &["preordered"], &["preorders"], &["personality"], &["personas"], ], - range: 3..=8, + range: 2..=9, }; static WORD_PERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30102,6 +57810,7 @@ static WORD_PERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ade"), + dictgen::InsensitiveStr::Ascii("ament"), dictgen::InsensitiveStr::Ascii("amently"), dictgen::InsensitiveStr::Ascii("anant"), dictgen::InsensitiveStr::Ascii("anantely"), @@ -30110,11 +57819,13 @@ pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("anenty"), dictgen::InsensitiveStr::Ascii("anet"), dictgen::InsensitiveStr::Ascii("anetly"), + dictgen::InsensitiveStr::Ascii("antly"), dictgen::InsensitiveStr::Ascii("ature"), dictgen::InsensitiveStr::Ascii("aturely"), dictgen::InsensitiveStr::Ascii("enant"), dictgen::InsensitiveStr::Ascii("enantly"), dictgen::InsensitiveStr::Ascii("enently"), + dictgen::InsensitiveStr::Ascii("essioned"), dictgen::InsensitiveStr::Ascii("ier"), dictgen::InsensitiveStr::Ascii("iere"), dictgen::InsensitiveStr::Ascii("ieter"), @@ -30122,6 +57833,7 @@ pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("inently"), dictgen::InsensitiveStr::Ascii("ise"), dictgen::InsensitiveStr::Ascii("ises"), + dictgen::InsensitiveStr::Ascii("ision"), dictgen::InsensitiveStr::Ascii("isions"), dictgen::InsensitiveStr::Ascii("isison"), dictgen::InsensitiveStr::Ascii("isisons"), @@ -30130,18 +57842,29 @@ pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("issibe"), dictgen::InsensitiveStr::Ascii("issie"), dictgen::InsensitiveStr::Ascii("issin"), + dictgen::InsensitiveStr::Ascii("issiosn"), dictgen::InsensitiveStr::Ascii("isson"), dictgen::InsensitiveStr::Ascii("issons"), dictgen::InsensitiveStr::Ascii("isssion"), + dictgen::InsensitiveStr::Ascii("isssions"), dictgen::InsensitiveStr::Ascii("itas"), + dictgen::InsensitiveStr::Ascii("ited"), dictgen::InsensitiveStr::Ascii("ites"), + dictgen::InsensitiveStr::Ascii("ition"), + dictgen::InsensitiveStr::Ascii("itions"), dictgen::InsensitiveStr::Ascii("itis"), dictgen::InsensitiveStr::Ascii("itts"), dictgen::InsensitiveStr::Ascii("ium"), dictgen::InsensitiveStr::Ascii("iums"), + dictgen::InsensitiveStr::Ascii("ormance"), + dictgen::InsensitiveStr::Ascii("uation"), + dictgen::InsensitiveStr::Ascii("uations"), + dictgen::InsensitiveStr::Ascii("utaion"), + dictgen::InsensitiveStr::Ascii("utaions"), ], values: &[ &["premade"], + &["permanent"], &["permanently"], &["permanent"], &["permanently"], @@ -30150,11 +57873,13 @@ pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["permanently"], &["permanent"], &["permanently"], + &["permanently"], &["premature"], &["prematurely"], &["permanent"], &["permanently"], &["permanently"], + &["permissioned"], &["premier"], &["premiere"], &["perimeter"], @@ -30163,6 +57888,7 @@ pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["premise"], &["premises"], &["permission"], + &["permission", "permissions"], &["permissions"], &["permissions"], &["permissible"], @@ -30170,15 +57896,25 @@ pub static WORD_PERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["permissible"], &["permissible"], &["permissions"], + &["permissions"], &["permission"], &["permissions"], + &["permissions", "permission"], &["permissions"], &["permits"], + &["permitted"], &["permits"], + &["permission"], + &["permissions"], &["permits"], &["permits"], &["premium"], &["premiums"], + &["performance"], + &["permutation"], + &["permutations"], + &["permutation"], + &["permutations"], ], range: 3..=8, }; @@ -30189,9 +57925,12 @@ static WORD_PERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_PERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iminary")], - values: &[&["preliminary"]], - range: 7..=7, + keys: &[ + dictgen::InsensitiveStr::Ascii("ciritc"), + dictgen::InsensitiveStr::Ascii("iminary"), + ], + values: &[&["perlcritic"], &["preliminary"]], + range: 6..=7, }; static WORD_PERJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30217,6 +57956,7 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("cing"), dictgen::InsensitiveStr::Ascii("cings"), + dictgen::InsensitiveStr::Ascii("dic"), dictgen::InsensitiveStr::Ascii("dinkle"), dictgen::InsensitiveStr::Ascii("doic"), dictgen::InsensitiveStr::Ascii("doically"), @@ -30224,8 +57964,11 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("hperals"), 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"), @@ -30244,6 +57987,7 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("phrial"), dictgen::InsensitiveStr::Ascii("phrials"), dictgen::InsensitiveStr::Ascii("san"), + dictgen::InsensitiveStr::Ascii("sist"), dictgen::InsensitiveStr::Ascii("stent"), dictgen::InsensitiveStr::Ascii("tinkle"), dictgen::InsensitiveStr::Ascii("wankle"), @@ -30255,6 +57999,7 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["piercing"], &["piercings"], + &["periodic"], &["periwinkle"], &["periodic"], &["periodically"], @@ -30262,9 +58007,12 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["peripherals"], &["perimeter"], &["perimeter"], + &["perimeters"], + &["period"], &["periods"], &["periodically"], &["periodic"], + &["periodic"], &["periods"], &["peripatetic"], &["peripheral"], @@ -30282,6 +58030,7 @@ pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["peripheral"], &["peripherals"], &["persian"], + &["persist"], &["persistent"], &["periwinkle"], &["periwinkle"], @@ -30300,6 +58049,8 @@ static WORD_PERH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -30307,104 +58058,451 @@ pub static WORD_PERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("pas"), ], values: &[ + &["perhaps"], + &["perhaps"], &["perhaps"], &["perhaps"], &["peripheral"], &["peripherals"], &["perhaps"], ], - range: 3..=7, + range: 2..=7, }; static WORD_PERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PERF_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PERF_CHILDREN), value: None, }; -pub static WORD_PERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + None, + None, + None, + None, + None, +]; + +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("eccion"), - dictgen::InsensitiveStr::Ascii("eclty"), - dictgen::InsensitiveStr::Ascii("ecty"), - dictgen::InsensitiveStr::Ascii("ecxion"), - dictgen::InsensitiveStr::Ascii("ektion"), - dictgen::InsensitiveStr::Ascii("erable"), - dictgen::InsensitiveStr::Ascii("erably"), - dictgen::InsensitiveStr::Ascii("erence"), - dictgen::InsensitiveStr::Ascii("erences"), - dictgen::InsensitiveStr::Ascii("erential"), - dictgen::InsensitiveStr::Ascii("erring"), - dictgen::InsensitiveStr::Ascii("ers"), - dictgen::InsensitiveStr::Ascii("excion"), + 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("omrance"), - dictgen::InsensitiveStr::Ascii("oramnce"), - dictgen::InsensitiveStr::Ascii("ormace"), - dictgen::InsensitiveStr::Ascii("ormaces"), - dictgen::InsensitiveStr::Ascii("ormacne"), - dictgen::InsensitiveStr::Ascii("ormancepcs"), - dictgen::InsensitiveStr::Ascii("ormancetest"), - dictgen::InsensitiveStr::Ascii("ormancewise"), - dictgen::InsensitiveStr::Ascii("ormane"), - dictgen::InsensitiveStr::Ascii("ormanes"), - dictgen::InsensitiveStr::Ascii("ormans"), - dictgen::InsensitiveStr::Ascii("ormanse"), - dictgen::InsensitiveStr::Ascii("ormantes"), - dictgen::InsensitiveStr::Ascii("ormas"), - dictgen::InsensitiveStr::Ascii("ormence"), - dictgen::InsensitiveStr::Ascii("ormences"), - dictgen::InsensitiveStr::Ascii("ormens"), - dictgen::InsensitiveStr::Ascii("ormnace"), - dictgen::InsensitiveStr::Ascii("ormous"), - dictgen::InsensitiveStr::Ascii("romance"), - dictgen::InsensitiveStr::Ascii("romances"), - dictgen::InsensitiveStr::Ascii("romer"), - dictgen::InsensitiveStr::Ascii("romers"), - dictgen::InsensitiveStr::Ascii("roms"), + dictgen::InsensitiveStr::Ascii("oming"), + dictgen::InsensitiveStr::Ascii("oms"), ], values: &[ - &["perfection"], - &["perfectly"], - &["perfectly"], - &["perfection"], - &["perfection"], - &["preferable"], - &["preferably"], - &["preference"], - &["preferences"], - &["preferential"], - &["preferring"], - &["prefers"], - &["perfection"], + &["perform"], &["performance"], + &["performances"], + &["performed"], + &["performer"], &["performers"], + &["performing"], + &["performs"], + ], + range: 2..=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: None, +}; + +pub static WORD_PERFOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("amnce"), + 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"), + ], + values: &[ + &["performances"], + &["performed"], + &["performance"], &["performances"], &["performances"], + &["performed"], &["performance"], &["performances"], &["performances"], &["performances"], - &["performances"], - &["performances"], - &["performances"], + &["performances", "performance"], &["performances"], &["performances"], &["performances"], &["performances"], &["performs"], + &["perform", "performed"], &["performance"], &["performances"], &["performers"], - &["performances"], + &["performed", "performs"], + &["performances", "performance"], &["performs"], + ], + range: 2..=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: 3..=11, + 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 { @@ -30418,14 +58516,18 @@ pub static WORD_PERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: 5..=7, + range: 4..=7, }; static WORD_PERD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30477,6 +58579,7 @@ pub static WORD_PERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -30512,6 +58615,7 @@ pub static WORD_PERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["percentile"], &["percentile"], &["percentile"], + &["percentile"], &["perceived"], &["perceptions"], &["percussion"], @@ -30542,9 +58646,12 @@ static WORD_PERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_PERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("de")], - values: &[&["parade"]], - range: 2..=2, + 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 { @@ -30554,22 +58661,28 @@ static WORD_PEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 5..=8, + range: 3..=8, }; static WORD_PEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30586,6 +58699,7 @@ pub static WORD_PEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ms"), dictgen::InsensitiveStr::Ascii("pel"), dictgen::InsensitiveStr::Ascii("pels"), + dictgen::InsensitiveStr::Ascii("pl"), dictgen::InsensitiveStr::Ascii("try"), ], values: &[ @@ -30596,85 +58710,217 @@ pub static WORD_PEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["poems"], &["people"], &["peoples"], + &["people"], &["poetry"], ], range: 1..=7, }; static WORD_PEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PEN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PEN_CHILDREN), value: None, }; -pub static WORD_PEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + None, + None, + None, +]; + +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("alites"), - dictgen::InsensitiveStr::Ascii("altis"), - dictgen::InsensitiveStr::Ascii("atgon"), - dictgen::InsensitiveStr::Ascii("atlies"), - dictgen::InsensitiveStr::Ascii("atly"), - dictgen::InsensitiveStr::Ascii("ciles"), - dictgen::InsensitiveStr::Ascii("datic"), - dictgen::InsensitiveStr::Ascii("dulm"), - dictgen::InsensitiveStr::Ascii("duluum"), - dictgen::InsensitiveStr::Ascii("erator"), - dictgen::InsensitiveStr::Ascii("etracion"), - dictgen::InsensitiveStr::Ascii("etrading"), - dictgen::InsensitiveStr::Ascii("etraion"), - dictgen::InsensitiveStr::Ascii("etrarion"), - dictgen::InsensitiveStr::Ascii("etratiing"), - dictgen::InsensitiveStr::Ascii("etratin"), - dictgen::InsensitiveStr::Ascii("etraton"), - dictgen::InsensitiveStr::Ascii("giuns"), - dictgen::InsensitiveStr::Ascii("guines"), - dictgen::InsensitiveStr::Ascii("guinese"), - dictgen::InsensitiveStr::Ascii("guiness"), - dictgen::InsensitiveStr::Ascii("guings"), - dictgen::InsensitiveStr::Ascii("guinos"), - dictgen::InsensitiveStr::Ascii("guis"), - dictgen::InsensitiveStr::Ascii("icls"), - dictgen::InsensitiveStr::Ascii("insual"), - dictgen::InsensitiveStr::Ascii("insulla"), - dictgen::InsensitiveStr::Ascii("inusla"), - dictgen::InsensitiveStr::Ascii("isnula"), - dictgen::InsensitiveStr::Ascii("ison"), - dictgen::InsensitiveStr::Ascii("isse"), - dictgen::InsensitiveStr::Ascii("isula"), - dictgen::InsensitiveStr::Ascii("isular"), - dictgen::InsensitiveStr::Ascii("isylvania"), - dictgen::InsensitiveStr::Ascii("itum"), - dictgen::InsensitiveStr::Ascii("ninsula"), - dictgen::InsensitiveStr::Ascii("ninsular"), - dictgen::InsensitiveStr::Ascii("nisula"), - dictgen::InsensitiveStr::Ascii("nsilvania"), - dictgen::InsensitiveStr::Ascii("nslyvania"), - dictgen::InsensitiveStr::Ascii("nsylvaina"), - dictgen::InsensitiveStr::Ascii("nsylvainia"), - dictgen::InsensitiveStr::Ascii("nsylvanica"), - dictgen::InsensitiveStr::Ascii("nsylvannia"), - dictgen::InsensitiveStr::Ascii("nsylvnia"), - dictgen::InsensitiveStr::Ascii("nsyvlania"), - dictgen::InsensitiveStr::Ascii("nyslvania"), - dictgen::InsensitiveStr::Ascii("sies"), - dictgen::InsensitiveStr::Ascii("sino"), - dictgen::InsensitiveStr::Ascii("sinula"), - dictgen::InsensitiveStr::Ascii("sioen"), - dictgen::InsensitiveStr::Ascii("sle"), - dictgen::InsensitiveStr::Ascii("ssylvania"), - dictgen::InsensitiveStr::Ascii("tagoon"), - dictgen::InsensitiveStr::Ascii("tsylvania"), - dictgen::InsensitiveStr::Ascii("tuim"), + dictgen::InsensitiveStr::Ascii("agoon"), + dictgen::InsensitiveStr::Ascii("sylvania"), + dictgen::InsensitiveStr::Ascii("uim"), + ], + values: &[&["pentagon"], &["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("insula"), + dictgen::InsensitiveStr::Ascii("insular"), + dictgen::InsensitiveStr::Ascii("isula"), + 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"], + &["peninsula"], + &["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: &[ - &["penalties"], - &["penalties"], - &["pentagon"], - &["penalties"], - &["penalty"], &["pencils"], - &["pedantic"], - &["pendulum"], - &["pendulum"], + &["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"), + ], + values: &[ + &["penguins"], + &["penguins"], + &["penguins"], + &["penguins"], + &["penguins"], + &["penguins"], + &["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"], @@ -30683,47 +58929,82 @@ pub static WORD_PEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["penetrating"], &["penetration"], &["penetration"], - &["penguins"], - &["penguins"], - &["penguins"], - &["penguins"], - &["penguins"], - &["penguins"], - &["penguins"], - &["pencils"], - &["peninsula"], - &["peninsula"], - &["peninsula"], - &["peninsula"], - &["pension"], - &["penises"], - &["peninsula"], - &["peninsular"], - &["pennsylvania"], - &["pentium"], - &["peninsula"], - &["peninsular"], - &["peninsula"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["pennsylvania"], - &["penises"], - &["pension"], - &["peninsula"], - &["pension"], - &["pencil"], - &["pennsylvania"], - &["pentagon"], - &["pennsylvania"], - &["pentium"], ], - range: 3..=10, + 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("tgon"), + dictgen::InsensitiveStr::Ascii("tlies"), + dictgen::InsensitiveStr::Ascii("tly"), + ], + values: &[ + &["penalties"], + &["penalties"], + &["penalty"], + &["penalties"], + &["pentagon"], + &["penalties"], + &["penalty"], + ], + range: 3..=6, +}; + +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 { @@ -30734,12 +59015,42 @@ static WORD_PEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], &["pierced"], &["piercing"], &["piercings"]], - range: 2..=6, + values: &[ + &["piece"], + &["piecemeal"], + &["pieces"], + &["piecewise"], + &["pierced"], + &["piercing"], + &["piercings"], + &["period"], + &["periodical"], + &["periodicals"], + &["periods"], + ], + range: 2..=8, +}; + +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 { @@ -30748,9 +59059,23 @@ static WORD_PEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_PEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ormed")], - values: &[&["performed"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("erence"), + dictgen::InsensitiveStr::Ascii("erences"), + dictgen::InsensitiveStr::Ascii("orm"), + dictgen::InsensitiveStr::Ascii("ormance"), + dictgen::InsensitiveStr::Ascii("ormed"), + dictgen::InsensitiveStr::Ascii("orming"), + ], + values: &[ + &["preference"], + &["preferences"], + &["perform"], + &["performance"], + &["performed"], + &["performing"], + ], + range: 3..=7, }; static WORD_PED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30766,6 +59091,8 @@ pub static WORD_PED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("estrain"), dictgen::InsensitiveStr::Ascii("estrains"), dictgen::InsensitiveStr::Ascii("ictions"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ning"), dictgen::InsensitiveStr::Ascii("ohpile"), dictgen::InsensitiveStr::Ascii("ohpiles"), dictgen::InsensitiveStr::Ascii("ohpilia"), @@ -30787,6 +59114,8 @@ pub static WORD_PED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["pedestrian"], &["pedestrians"], &["depictions"], + &["pending"], + &["pending"], &["pedophile"], &["pedophiles"], &["pedophilia"], @@ -30801,7 +59130,7 @@ pub static WORD_PED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["pedophiles"], &["pedophilia"], ], - range: 6..=8, + range: 3..=8, }; static WORD_PEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30811,13 +59140,26 @@ static WORD_PEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["peculiar"], &["peculiar"], &["peculiar"], &["peculiar"]], - range: 5..=5, + values: &[ + &["percentage"], + &["specified", "pacified"], + &["peculiar"], + &["peculiar"], + &["peculiar"], + &["peculiarities"], + &["peculiarity"], + &["peculiar"], + ], + range: 5..=9, }; static WORD_PEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30843,20 +59185,24 @@ static WORD_PEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ple"), dictgen::InsensitiveStr::Ascii("ples"), ], values: &[ + &["peace"], &["peacefully"], &["peacefully"], + &["pacify"], &["pageant"], &["people"], &["peoples"], ], - range: 3..=8, + range: 2..=8, }; static WORD_PB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -30879,13 +59225,13 @@ static WORD_PA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_PAA_NODE), None, Some(&WORD_PAC_NODE), - None, - None, + Some(&WORD_PAD_NODE), + Some(&WORD_PAE_NODE), Some(&WORD_PAF_NODE), - None, + Some(&WORD_PAG_NODE), Some(&WORD_PAH_NODE), Some(&WORD_PAI_NODE), None, @@ -30893,7 +59239,7 @@ static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_PAL_NODE), Some(&WORD_PAM_NODE), Some(&WORD_PAN_NODE), - None, + Some(&WORD_PAO_NODE), Some(&WORD_PAP_NODE), None, Some(&WORD_PAR_NODE), @@ -30942,103 +59288,127 @@ static WORD_PAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_PAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("illion")], - values: &[&["pavilion"]], - range: 6..=6, + 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::Flat(&WORD_PAT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PAT_CHILDREN), value: None, }; -pub static WORD_PAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_PAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + 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("eince"), - dictgen::InsensitiveStr::Ascii("eint"), - dictgen::InsensitiveStr::Ascii("eintly"), - dictgen::InsensitiveStr::Ascii("eints"), - dictgen::InsensitiveStr::Ascii("enterad"), - dictgen::InsensitiveStr::Ascii("ethic"), - dictgen::InsensitiveStr::Ascii("halogical"), - dictgen::InsensitiveStr::Ascii("hces"), - dictgen::InsensitiveStr::Ascii("heitc"), - dictgen::InsensitiveStr::Ascii("helogical"), - dictgen::InsensitiveStr::Ascii("hfidner"), - dictgen::InsensitiveStr::Ascii("hfindir"), - dictgen::InsensitiveStr::Ascii("hifnder"), - dictgen::InsensitiveStr::Ascii("holigical"), - dictgen::InsensitiveStr::Ascii("hologial"), - dictgen::InsensitiveStr::Ascii("icular"), - dictgen::InsensitiveStr::Ascii("iens"), - dictgen::InsensitiveStr::Ascii("ientens"), - dictgen::InsensitiveStr::Ascii("ienty"), - dictgen::InsensitiveStr::Ascii("inetly"), - dictgen::InsensitiveStr::Ascii("irot"), - dictgen::InsensitiveStr::Ascii("irots"), - dictgen::InsensitiveStr::Ascii("rairchy"), - dictgen::InsensitiveStr::Ascii("rcik"), - dictgen::InsensitiveStr::Ascii("riachry"), - dictgen::InsensitiveStr::Ascii("riarca"), - dictgen::InsensitiveStr::Ascii("riarcal"), - dictgen::InsensitiveStr::Ascii("riarchia"), - dictgen::InsensitiveStr::Ascii("riarcial"), - dictgen::InsensitiveStr::Ascii("riarcy"), - dictgen::InsensitiveStr::Ascii("riarh"), - dictgen::InsensitiveStr::Ascii("riarhal"), - dictgen::InsensitiveStr::Ascii("riarical"), - dictgen::InsensitiveStr::Ascii("riatchy"), - dictgen::InsensitiveStr::Ascii("riatism"), - dictgen::InsensitiveStr::Ascii("rionism"), - dictgen::InsensitiveStr::Ascii("rios"), - dictgen::InsensitiveStr::Ascii("riotas"), - dictgen::InsensitiveStr::Ascii("riotes"), - dictgen::InsensitiveStr::Ascii("riotics"), - dictgen::InsensitiveStr::Ascii("riotisch"), - dictgen::InsensitiveStr::Ascii("riotisim"), - dictgen::InsensitiveStr::Ascii("riotisk"), - dictgen::InsensitiveStr::Ascii("riottism"), - dictgen::InsensitiveStr::Ascii("roit"), - dictgen::InsensitiveStr::Ascii("roitic"), - dictgen::InsensitiveStr::Ascii("roitism"), - dictgen::InsensitiveStr::Ascii("roits"), - dictgen::InsensitiveStr::Ascii("rolls"), - dictgen::InsensitiveStr::Ascii("ronas"), - dictgen::InsensitiveStr::Ascii("rones"), - dictgen::InsensitiveStr::Ascii("ronis"), - dictgen::InsensitiveStr::Ascii("ronos"), - dictgen::InsensitiveStr::Ascii("ronozing"), - dictgen::InsensitiveStr::Ascii("ryarchy"), - dictgen::InsensitiveStr::Ascii("tened"), - dictgen::InsensitiveStr::Ascii("tented"), - dictgen::InsensitiveStr::Ascii("terno"), - dictgen::InsensitiveStr::Ascii("tersn"), + 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"), ], values: &[ - &["patience"], - &["patient"], - &["patiently"], - &["patients"], + &["pattern", "patent"], + &["patented", "patterned"], + &["patterns", "patents"], &["patented"], - &["pathetic"], - &["pathological"], - &["patches"], - &["pathetic"], - &["pathological"], - &["pathfinder"], - &["pathfinder"], - &["pathfinder"], - &["pathological"], - &["pathological"], - &["particular"], - &["patients"], - &["patients"], - &["patiently"], - &["patiently"], - &["patriot"], - &["patriots"], + &["patterson"], + &["patterson", "patterns"], + &["pattern", "patron"], + &["patterns", "patrons"], + ], + 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"], @@ -31070,12 +59440,128 @@ pub static WORD_PAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["patrons"], &["patronizing"], &["patriarchy"], - &["patented"], - &["patented"], - &["patterson"], - &["patterson"], ], - range: 4..=9, + 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("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("nme"), + dictgen::InsensitiveStr::Ascii("olgoical"), + dictgen::InsensitiveStr::Ascii("oligical"), + dictgen::InsensitiveStr::Ascii("ologial"), + ], + values: &[ + &["pathological"], + &["pathname"], + &["patched"], + &["patches"], + &["pathetic"], + &["pathological"], + &["paths"], + &["pathfinder"], + &["pathfinder"], + &["pathfinder"], + &["pathing"], + &["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_PAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31085,13 +59571,24 @@ static WORD_PAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_PAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("e"), dictgen::InsensitiveStr::Ascii("ed"), dictgen::InsensitiveStr::Ascii("engers"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("esd"), + dictgen::InsensitiveStr::Ascii("h"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("itioning"), + dictgen::InsensitiveStr::Ascii("ive"), + dictgen::InsensitiveStr::Ascii("re"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("res"), dictgen::InsensitiveStr::Ascii("sabe"), dictgen::InsensitiveStr::Ascii("sabel"), dictgen::InsensitiveStr::Ascii("sagens"), dictgen::InsensitiveStr::Ascii("sagers"), dictgen::InsensitiveStr::Ascii("serbys"), + dictgen::InsensitiveStr::Ascii("sin"), dictgen::InsensitiveStr::Ascii("sionais"), dictgen::InsensitiveStr::Ascii("sionale"), dictgen::InsensitiveStr::Ascii("sionant"), @@ -31104,27 +59601,51 @@ pub static WORD_PAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("sionite"), dictgen::InsensitiveStr::Ascii("sionnate"), dictgen::InsensitiveStr::Ascii("sisve"), + dictgen::InsensitiveStr::Ascii("siv"), dictgen::InsensitiveStr::Ascii("sivedns"), dictgen::InsensitiveStr::Ascii("sivelly"), dictgen::InsensitiveStr::Ascii("sivley"), dictgen::InsensitiveStr::Ascii("sivs"), + dictgen::InsensitiveStr::Ascii("sowrd"), dictgen::InsensitiveStr::Ascii("sowrds"), dictgen::InsensitiveStr::Ascii("sporters"), dictgen::InsensitiveStr::Ascii("spost"), + dictgen::InsensitiveStr::Ascii("sthrought"), + dictgen::InsensitiveStr::Ascii("sthruogh"), + dictgen::InsensitiveStr::Ascii("stime"), + dictgen::InsensitiveStr::Ascii("strough"), dictgen::InsensitiveStr::Ascii("svies"), + dictgen::InsensitiveStr::Ascii("swird"), + dictgen::InsensitiveStr::Ascii("swirds"), dictgen::InsensitiveStr::Ascii("swors"), + dictgen::InsensitiveStr::Ascii("swrod"), + dictgen::InsensitiveStr::Ascii("swrods"), + dictgen::InsensitiveStr::Ascii("teing"), dictgen::InsensitiveStr::Ascii("ttime"), dictgen::InsensitiveStr::Ascii("tural"), dictgen::InsensitiveStr::Ascii("uing"), + dictgen::InsensitiveStr::Ascii("word"), + dictgen::InsensitiveStr::Ascii("words"), ], values: &[ - &["passed"], + &["pass", "pace", "parse"], + &["passed", "parsed"], &["passengers"], + &["parser"], + &["passed"], + &["hash"], + &["passing", "posing"], + &["positioning"], + &["passive"], + &["parse"], + &["parsed"], + &["parses"], &["passable"], &["passable"], &["passages"], &["passages"], &["passersby"], + &["passing"], &["passions"], &["passionately"], &["passionate"], @@ -31137,20 +59658,33 @@ pub static WORD_PAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["passionate"], &["passionate"], &["passives"], + &["passive"], &["passives"], &["passively"], &["passively"], &["passives"], + &["password"], &["passwords"], &["passports"], &["passports"], + &["passthrough"], + &["passthrough"], + &["pastime"], + &["passthrough"], &["passives"], + &["password"], &["passwords"], + &["passwords"], + &["password"], + &["passwords"], + &["pasting"], &["pastime"], &["pastoral"], &["pausing"], + &["password"], + &["passwords"], ], - range: 2..=10, + range: 1..=10, }; static WORD_PAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31162,7 +59696,7 @@ static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_PARA_NODE), None, Some(&WORD_PARC_NODE), - None, + Some(&WORD_PARD_NODE), Some(&WORD_PARE_NODE), None, None, @@ -31177,23 +59711,34 @@ static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_PARR_NODE), - None, + Some(&WORD_PARS_NODE), Some(&WORD_PART_NODE), None, 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] = [ - None, + Some(&WORD_PARTA_NODE), None, Some(&WORD_PARTC_NODE), None, @@ -31261,75 +59806,284 @@ pub static WORD_PARTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_PARTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_PARTI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_PARTI_CHILDREN), value: None, }; -pub static WORD_PARTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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_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("aly"), - dictgen::InsensitiveStr::Ascii("ans"), - dictgen::InsensitiveStr::Ascii("archal"), - dictgen::InsensitiveStr::Ascii("archy"), - dictgen::InsensitiveStr::Ascii("cal"), - dictgen::InsensitiveStr::Ascii("capate"), - dictgen::InsensitiveStr::Ascii("capated"), - dictgen::InsensitiveStr::Ascii("ce"), - dictgen::InsensitiveStr::Ascii("cel"), - dictgen::InsensitiveStr::Ascii("ciapnts"), - dictgen::InsensitiveStr::Ascii("ciapte"), - dictgen::InsensitiveStr::Ascii("ciapted"), - dictgen::InsensitiveStr::Ascii("ciaption"), - dictgen::InsensitiveStr::Ascii("cipacion"), - dictgen::InsensitiveStr::Ascii("cipait"), - dictgen::InsensitiveStr::Ascii("cipans"), - dictgen::InsensitiveStr::Ascii("cipante"), - dictgen::InsensitiveStr::Ascii("cipantes"), - dictgen::InsensitiveStr::Ascii("cipare"), - dictgen::InsensitiveStr::Ascii("cipas"), - dictgen::InsensitiveStr::Ascii("cipaste"), - dictgen::InsensitiveStr::Ascii("cipat"), - dictgen::InsensitiveStr::Ascii("cipatd"), - dictgen::InsensitiveStr::Ascii("cipati"), - dictgen::InsensitiveStr::Ascii("cipatie"), - dictgen::InsensitiveStr::Ascii("cipatin"), - dictgen::InsensitiveStr::Ascii("cipativo"), - dictgen::InsensitiveStr::Ascii("cipatns"), - dictgen::InsensitiveStr::Ascii("cipaton"), - dictgen::InsensitiveStr::Ascii("cipats"), - dictgen::InsensitiveStr::Ascii("cipe"), - dictgen::InsensitiveStr::Ascii("cipent"), - dictgen::InsensitiveStr::Ascii("cipents"), - dictgen::InsensitiveStr::Ascii("cipte"), - dictgen::InsensitiveStr::Ascii("ck"), - dictgen::InsensitiveStr::Ascii("cpiate"), - dictgen::InsensitiveStr::Ascii("cually"), - dictgen::InsensitiveStr::Ascii("cualr"), - dictgen::InsensitiveStr::Ascii("cualrly"), - dictgen::InsensitiveStr::Ascii("culalry"), - dictgen::InsensitiveStr::Ascii("culaly"), - dictgen::InsensitiveStr::Ascii("cularely"), - dictgen::InsensitiveStr::Ascii("cularily"), - dictgen::InsensitiveStr::Ascii("cularlly"), - dictgen::InsensitiveStr::Ascii("culary"), - dictgen::InsensitiveStr::Ascii("cullary"), - dictgen::InsensitiveStr::Ascii("el"), - dictgen::InsensitiveStr::Ascii("ets"), - dictgen::InsensitiveStr::Ascii("ot"), - dictgen::InsensitiveStr::Ascii("otic"), - dictgen::InsensitiveStr::Ascii("otism"), - dictgen::InsensitiveStr::Ascii("ots"), - dictgen::InsensitiveStr::Ascii("sain"), - dictgen::InsensitiveStr::Ascii("zipation"), + dictgen::InsensitiveStr::Ascii("ial"), + dictgen::InsensitiveStr::Ascii("icular"), + dictgen::InsensitiveStr::Ascii("ioing"), + dictgen::InsensitiveStr::Ascii("iones"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("oned"), + dictgen::InsensitiveStr::Ascii("oning"), + dictgen::InsensitiveStr::Ascii("ons"), ], values: &[ - &["partially"], - &["partisan"], - &["patriarchal"], - &["patriarchy"], + &["partial"], &["particular"], + &["partitioning"], + &["partitions"], + &["partition"], + &["partitioned"], + &["partitioning"], + &["partitions"], + ], + range: 2..=6, +}; + +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::Flat(&WORD_PARTIC_CHILDREN), + value: None, +}; + +pub static WORD_PARTIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("al"), + dictgen::InsensitiveStr::Ascii("alar"), + dictgen::InsensitiveStr::Ascii("alarly"), + dictgen::InsensitiveStr::Ascii("ale"), + dictgen::InsensitiveStr::Ascii("ales"), + dictgen::InsensitiveStr::Ascii("ally"), + dictgen::InsensitiveStr::Ascii("als"), + dictgen::InsensitiveStr::Ascii("aluar"), + dictgen::InsensitiveStr::Ascii("aluarly"), + dictgen::InsensitiveStr::Ascii("alur"), + dictgen::InsensitiveStr::Ascii("alurly"), + dictgen::InsensitiveStr::Ascii("ant"), + dictgen::InsensitiveStr::Ascii("apate"), + dictgen::InsensitiveStr::Ascii("apated"), + dictgen::InsensitiveStr::Ascii("aular"), + dictgen::InsensitiveStr::Ascii("aularly"), + dictgen::InsensitiveStr::Ascii("aulr"), + dictgen::InsensitiveStr::Ascii("aulrly"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("el"), + dictgen::InsensitiveStr::Ascii("iapnts"), + dictgen::InsensitiveStr::Ascii("iapte"), + dictgen::InsensitiveStr::Ascii("iapted"), + dictgen::InsensitiveStr::Ascii("iaption"), + dictgen::InsensitiveStr::Ascii("ipacion"), + dictgen::InsensitiveStr::Ascii("ipait"), + dictgen::InsensitiveStr::Ascii("ipans"), + dictgen::InsensitiveStr::Ascii("ipante"), + dictgen::InsensitiveStr::Ascii("ipantes"), + dictgen::InsensitiveStr::Ascii("ipare"), + dictgen::InsensitiveStr::Ascii("ipas"), + dictgen::InsensitiveStr::Ascii("ipaste"), + dictgen::InsensitiveStr::Ascii("ipat"), + dictgen::InsensitiveStr::Ascii("ipatd"), + dictgen::InsensitiveStr::Ascii("ipati"), + dictgen::InsensitiveStr::Ascii("ipatie"), + dictgen::InsensitiveStr::Ascii("ipatin"), + dictgen::InsensitiveStr::Ascii("ipativo"), + dictgen::InsensitiveStr::Ascii("ipatns"), + dictgen::InsensitiveStr::Ascii("ipaton"), + dictgen::InsensitiveStr::Ascii("ipats"), + dictgen::InsensitiveStr::Ascii("ipe"), + dictgen::InsensitiveStr::Ascii("ipent"), + dictgen::InsensitiveStr::Ascii("ipents"), + dictgen::InsensitiveStr::Ascii("ipte"), + dictgen::InsensitiveStr::Ascii("k"), + dictgen::InsensitiveStr::Ascii("piate"), + dictgen::InsensitiveStr::Ascii("ually"), + dictgen::InsensitiveStr::Ascii("ualr"), + dictgen::InsensitiveStr::Ascii("ualrly"), + dictgen::InsensitiveStr::Ascii("uar"), + dictgen::InsensitiveStr::Ascii("uarly"), + dictgen::InsensitiveStr::Ascii("ulalry"), + dictgen::InsensitiveStr::Ascii("ulaly"), + dictgen::InsensitiveStr::Ascii("ularely"), + dictgen::InsensitiveStr::Ascii("ularily"), + dictgen::InsensitiveStr::Ascii("ularlly"), + dictgen::InsensitiveStr::Ascii("ulary"), + dictgen::InsensitiveStr::Ascii("ullary"), + ], + values: &[ + &["particular", "partial", "particle"], + &["particular"], + &["particularly"], + &["particle"], + &["particles"], + &["partially"], + &["particles"], + &["particular"], + &["particularly"], + &["particular"], + &["particularly"], + &["participant"], &["participate"], &["participated"], + &["particular"], + &["particularly"], + &["particular"], + &["particularly"], &["particle"], &["particle"], &["participant"], @@ -31362,6 +60116,8 @@ pub static WORD_PARTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["particularly"], &["particular"], &["particularly"], + &["particular"], + &["particularly"], &["particularly"], &["particularly"], &["particularly"], @@ -31369,16 +60125,29 @@ pub static WORD_PARTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["particularly"], &["particularly"], &["particularly"], - &["particle"], - &["parties"], - &["patriot"], - &["patriotic"], - &["patriotism"], - &["patriots"], - &["partisan"], - &["participation"], ], - range: 2..=8, + range: 1..=7, +}; + +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_PARTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31421,6 +60190,32 @@ pub static WORD_PARTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di range: 4..=4, }; +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("eing"), + dictgen::InsensitiveStr::Ascii("ering"), + dictgen::InsensitiveStr::Ascii("in"), + ], + values: &[&["parsing"], &["parsing"], &["parsing"]], + range: 2..=5, +}; + static WORD_PARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PARR_CHILDREN), value: None, @@ -31433,6 +60228,7 @@ pub static WORD_PARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("allell"), dictgen::InsensitiveStr::Ascii("allelly"), dictgen::InsensitiveStr::Ascii("allely"), + dictgen::InsensitiveStr::Ascii("ent"), ], values: &[ &["parallel"], @@ -31440,8 +60236,9 @@ pub static WORD_PARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["parallel"], &["parallelly"], &["parallelly"], + &["parent"], ], - range: 4..=7, + range: 3..=7, }; static WORD_PARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31451,28 +60248,59 @@ static WORD_PARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("oia"), dictgen::InsensitiveStr::Ascii("tered"), dictgen::InsensitiveStr::Ascii("ters"), dictgen::InsensitiveStr::Ascii("tership"), ], - values: &[&["partnered"], &["partners"], &["partnership"]], - range: 4..=7, + values: &[ + &["paranoia"], + &["partnered"], + &["partners"], + &["partnership"], + ], + range: 3..=7, }; static WORD_PARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PARM_CHILDREN), - value: None, + 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("eter"), + dictgen::InsensitiveStr::Ascii("eters"), + dictgen::InsensitiveStr::Ascii("s"), dictgen::InsensitiveStr::Ascii("sean"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("ters"), ], - values: &[&["parmesan"], &["parmesan"], &["parmesan"], &["parmesan"]], - range: 4..=5, + values: &[ + &["parameter"], + &["parameters"], + &["parameter"], + &["parameters"], + &["parmesan"], + &["parameters"], + &["parmesan"], + &["parmesan"], + &["parameter"], + &["parameters"], + &["params", "prams"], + &["parmesan"], + &["parameter"], + &["parameters"], + ], + range: 1..=7, }; static WORD_PARL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31521,6 +60349,8 @@ static WORD_PARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("al"), + dictgen::InsensitiveStr::Ascii("ally"), dictgen::InsensitiveStr::Ascii("cular"), dictgen::InsensitiveStr::Ascii("lament"), dictgen::InsensitiveStr::Ascii("lamentary"), @@ -31529,9 +60359,16 @@ pub static WORD_PARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("stan"), dictgen::InsensitiveStr::Ascii("tally"), dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("tial"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tioning"), + dictgen::InsensitiveStr::Ascii("tition"), + dictgen::InsensitiveStr::Ascii("titions"), dictgen::InsensitiveStr::Ascii("tuclar"), ], values: &[ + &["partial"], + &["partially"], &["particular"], &["parliament"], &["parliamentary"], @@ -31540,9 +60377,14 @@ pub static WORD_PARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["partisan"], &["partially"], &["parties"], + &["partial"], + &["partition"], + &["partitioning"], + &["partition"], + &["partitions"], &["particular"], ], - range: 3..=9, + range: 2..=9, }; static WORD_PARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31552,26 +60394,59 @@ static WORD_PARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_PARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("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"), ], values: &[ + &["parallelogram"], &["parallels"], + &["param"], + &["parameter"], + &["parameters"], &["parmesan"], + &["parameter"], + &["parameters"], + &["parentheses", "parenthesis"], &["parenthesis"], &["parentheses"], + &["parenthesized"], + &["parentheses"], &["parenthesis"], &["parentheses"], + &["parenthesis", "parentheses"], &["parenthesis"], &["parenthesis"], + &["parent", "parrot"], ], - range: 4..=8, + 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 { @@ -31580,9 +60455,13 @@ static WORD_PARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_PARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tise")], - values: &[&["practise"]], - range: 4..=4, + 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 { @@ -31595,8 +60474,8 @@ static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_PARAC_NODE), Some(&WORD_PARAD_NODE), - None, - None, + Some(&WORD_PARAE_NODE), + Some(&WORD_PARAF_NODE), Some(&WORD_PARAG_NODE), Some(&WORD_PARAH_NODE), Some(&WORD_PARAI_NODE), @@ -31608,11 +60487,11 @@ static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_PARAP_NODE), None, - None, + Some(&WORD_PARAR_NODE), Some(&WORD_PARAS_NODE), + Some(&WORD_PARAT_NODE), None, - None, - None, + Some(&WORD_PARAV_NODE), None, None, Some(&WORD_PARAY_NODE), @@ -31633,6 +60512,42 @@ pub static WORD_PARAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("irutalisation"), + dictgen::InsensitiveStr::Ascii("irutalise"), + dictgen::InsensitiveStr::Ascii("irutalised"), + dictgen::InsensitiveStr::Ascii("irutalization"), + dictgen::InsensitiveStr::Ascii("irutalize"), + dictgen::InsensitiveStr::Ascii("irutalized"), + ], + values: &[ + &["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("mers")], + values: &[&["parameters"]], + range: 4..=4, +}; + static WORD_PARAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PARAS_CHILDREN), value: None, @@ -31644,6 +60559,8 @@ pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), ], @@ -31652,12 +60569,39 @@ pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["parasites"], &["parasites"], &["parasite"], + &["parasitic"], + &["parasitics"], &["parasite"], &["parasites"], ], range: 3..=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("meters"), + ], + values: &[ + &["paragraph"], + &["paragraph"], + &["parameter"], + &["paragraph"], + &["paragraphs"], + &["parameters"], + ], + range: 3..=6, +}; + static WORD_PARAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PARAP_CHILDREN), value: None, @@ -31665,6 +60609,7 @@ static WORD_PARAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -31680,6 +60625,7 @@ pub static WORD_PARAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("rhasing"), ], values: &[ + &["paraphernalia"], &["paraphrase"], &["paraphrase"], &["paraphrasing"], @@ -31704,6 +60650,8 @@ static WORD_PARAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -31712,9 +60660,14 @@ pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("oida"), dictgen::InsensitiveStr::Ascii("omral"), dictgen::InsensitiveStr::Ascii("ornal"), + dictgen::InsensitiveStr::Ascii("oya"), + dictgen::InsensitiveStr::Ascii("thes"), + dictgen::InsensitiveStr::Ascii("theses"), dictgen::InsensitiveStr::Ascii("thesis"), ], values: &[ + &["piranha"], + &["paranoiac"], &["paranoia"], &["paranoid"], &["paranoia"], @@ -31723,9 +60676,12 @@ pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["paranoia"], &["paranormal"], &["paranormal"], + &["paranoia"], + &["parentheses", "parenthesis"], + &["parentheses"], &["parenthesis"], ], - range: 2..=6, + range: 1..=6, }; static WORD_PARAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31736,37 +60692,101 @@ static WORD_PARAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_PARAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("adics"), + 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("emeter"), + dictgen::InsensitiveStr::Ascii("emeters"), + dictgen::InsensitiveStr::Ascii("emter"), + dictgen::InsensitiveStr::Ascii("emters"), + dictgen::InsensitiveStr::Ascii("enet"), + dictgen::InsensitiveStr::Ascii("enets"), + dictgen::InsensitiveStr::Ascii("enters"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("ert"), + dictgen::InsensitiveStr::Ascii("erters"), + dictgen::InsensitiveStr::Ascii("erts"), + dictgen::InsensitiveStr::Ascii("eteras"), + dictgen::InsensitiveStr::Ascii("etere"), dictgen::InsensitiveStr::Ascii("eteres"), + dictgen::InsensitiveStr::Ascii("eterical"), + 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("etros"), + 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("terization"), + dictgen::InsensitiveStr::Ascii("terize"), + dictgen::InsensitiveStr::Ascii("terless"), dictgen::InsensitiveStr::Ascii("ters"), + dictgen::InsensitiveStr::Ascii("trical"), ], values: &[ &["paramedics"], &["parameters"], - &["paramedics"], - &["paramedics"], - &["paramedics"], - &["paramedics"], - &["paramedics"], + &["parameter"], &["parameters"], &["paramedics"], + &["paramedics"], + &["paramedics"], + &["paramedics"], + &["paramedics"], + &["parameter"], + &["parameters"], + &["parameter"], + &["parameters"], + &["parameter"], + &["parameters"], + &["parameters"], + &["parameter"], + &["parameter"], + &["parameters"], + &["parameters"], + &["parameters"], + &["parameter", "parameters"], + &["parameters"], + &["parametrical"], + &["parameters"], + &["parameters"], + &["parametric", "paramedic"], + &["paramedics"], + &["parametrised"], + &["parameter"], + &["parameters"], + &["parameter"], &["parameters"], &["parameters"], &["paranormal"], + &["params"], + &["parameter"], &["parameter"], &["parameters"], + &["parameters"], + &["parametric", "parametrically"], + &["parametrization", "parameterization"], + &["parameterize"], + &["parameterless"], + &["parameters"], + &["parametrical"], ], - range: 3..=6, + range: 2..=10, }; static WORD_PARAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31777,31 +60797,55 @@ static WORD_PARAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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("zyed"), ], values: &[ &["parallel"], + &["parallelising"], + &["parallelism"], + &["parallelizing"], &["parallel"], + &["parallel"], + &["parallelism"], + &["parallelization"], &["parallels"], &["parallelly"], &["parallelly"], &["paralysis"], &["parallels"], + &["parallel"], &["parallels"], &["parallelly"], &["parallels"], + &["parallelization"], + &["parallelize"], + &["parallelized"], + &["parallelizes"], + &["parallelizing"], &["paralyzed"], ], - range: 2..=5, + range: 2..=10, }; static WORD_PARAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31821,9 +60865,12 @@ static WORD_PARAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_PARAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("prase")], - values: &[&["paraphrase"]], - range: 5..=5, + 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 { @@ -31833,26 +60880,70 @@ static WORD_PARAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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"], + &["paragraph"], &["paragraphs"], &["paragraph"], &["paragraphs"], + &["paragraphs"], ], - range: 3..=6, + 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 { @@ -31866,8 +60957,10 @@ pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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: &[ @@ -31875,8 +60968,10 @@ pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["paradise"], &["paradigm"], &["paradigm"], + &["paradigm"], &["paradise"], &["parades"], + &["paradigm"], &["parades"], ], range: 2..=5, @@ -31907,6 +61002,20 @@ pub static WORD_PAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -31923,8 +61032,12 @@ pub static WORD_PAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -31940,14 +61053,18 @@ pub static WORD_PAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["pandora"], &["pandemic"], &["pantheon"], + &["panicked"], + &["panicking"], &["pancakes"], &["pandemic"], + &["panel"], + &["panels"], &["pantheon"], &["pantheon"], &["pantheon"], &["pantomime"], ], - range: 4..=6, + range: 3..=6, }; static WORD_PAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -31975,10 +61092,12 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -31995,14 +61114,19 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -32020,10 +61144,12 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["paladins"], &["paladins"], &["palestinians"], - &["place"], + &["palette"], + &["place", "palace"], &["placebo"], &["placeholder"], &["placements"], + &["places", "pales"], &["paleolithic"], &["palestinians"], &["palestinians"], @@ -32040,14 +61166,19 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["palestinian"], &["palestinians"], &["palestinians"], + &["palette"], &["parliamentarian"], &["paladins"], &["palestinian"], &["palestinian"], &["palestinians"], &["palette"], + &["palette"], + &["paletted"], + &["plan", "pain", "palm"], &["plaster"], &["plastics"], + &["palette"], &["platform"], &["platformer"], &["platforms"], @@ -32060,7 +61191,7 @@ pub static WORD_PAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["playthrough"], &["playthroughs"], ], - range: 2..=11, + range: 1..=11, }; static WORD_PAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32070,6 +61201,12 @@ static WORD_PAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("et"), + dictgen::InsensitiveStr::Ascii("ge"), dictgen::InsensitiveStr::Ascii("istain"), dictgen::InsensitiveStr::Ascii("istanais"), dictgen::InsensitiveStr::Ascii("istanezi"), @@ -32077,8 +61214,15 @@ pub static WORD_PAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("istian"), dictgen::InsensitiveStr::Ascii("istnai"), dictgen::InsensitiveStr::Ascii("sitani"), + dictgen::InsensitiveStr::Ascii("vage"), ], values: &[ + &["package"], + &["packageimpl"], + &["packages"], + &["package"], + &["packet"], + &["package"], &["pakistani"], &["pakistani"], &["pakistani"], @@ -32086,8 +61230,9 @@ pub static WORD_PAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["pakistani"], &["pakistani"], &["pakistani"], + &["package"], ], - range: 6..=8, + range: 2..=8, }; static WORD_PAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32098,31 +61243,41 @@ static WORD_PAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], &["patience"], &["patient"], &["patiently"], &["patients"], &["patience"], + &["painting"], ], range: 2..=9, }; @@ -32135,10 +61290,30 @@ static WORD_PAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["pathfinder"]], - range: 4..=7, + 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")], + values: &[&["paragraph"]], + range: 6..=6, }; static WORD_PAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32152,6 +61327,35 @@ pub static WORD_PAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("th"), + ], + values: &[&["permission"], &["permissions"], &["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("ing"), + ], + values: &[&["param"], &["padding"]], + range: 2..=3, +}; + static WORD_PAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_PAC_CHILDREN), value: None, @@ -32161,28 +61365,97 @@ pub static WORD_PAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ 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("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("kaing"), + dictgen::InsensitiveStr::Ascii("ke"), + dictgen::InsensitiveStr::Ascii("kege"), dictgen::InsensitiveStr::Ascii("kge"), + dictgen::InsensitiveStr::Ascii("kged"), + dictgen::InsensitiveStr::Ascii("kgement"), + dictgen::InsensitiveStr::Ascii("kges"), + dictgen::InsensitiveStr::Ascii("khage"), + dictgen::InsensitiveStr::Ascii("khages"), + dictgen::InsensitiveStr::Ascii("ktes"), + dictgen::InsensitiveStr::Ascii("tch"), + dictgen::InsensitiveStr::Ascii("tched"), + dictgen::InsensitiveStr::Ascii("tches"), dictgen::InsensitiveStr::Ascii("thes"), dictgen::InsensitiveStr::Ascii("tivity"), ], values: &[ &["package"], &["packaged"], + &["packages"], + &["packaging"], + &["placeholder"], + &["patch", "path"], + &["package"], + &["patches"], + &["patch"], + &["patches"], + &["patches"], &["pacifist"], &["pacifist"], - &["packaged"], + &["package"], + &["packages"], + &["package"], &["packaged"], &["packaged"], &["package"], + &["package"], + &["packages"], + &["packages"], + &["package"], + &["packaged"], + &["packaging"], + &["packed", "packet"], + &["package"], + &["package"], + &["packaged"], + &["packaging"], + &["packages"], + &["package"], + &["packages"], + &["packets"], + &["patch"], + &["patched"], + &["patches"], &["patches"], &["captivity"], ], - range: 3..=6, + 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")], + values: &[&["package"]], + range: 5..=5, }; static WORD_O_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32194,18 +61467,18 @@ static WORD_O_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_OA_NODE), Some(&WORD_OB_NODE), Some(&WORD_OC_NODE), - None, - None, + Some(&WORD_OD_NODE), + Some(&WORD_OE_NODE), Some(&WORD_OF_NODE), Some(&WORD_OG_NODE), - None, + Some(&WORD_OH_NODE), Some(&WORD_OI_NODE), - None, - None, + Some(&WORD_OJ_NODE), + Some(&WORD_OK_NODE), Some(&WORD_OL_NODE), Some(&WORD_OM_NODE), Some(&WORD_ON_NODE), - None, + Some(&WORD_OO_NODE), Some(&WORD_OP_NODE), None, Some(&WORD_OR_NODE), @@ -32228,9 +61501,10 @@ pub static WORD_OY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("lmpic"), dictgen::InsensitiveStr::Ascii("lmpics"), + dictgen::InsensitiveStr::Ascii("u"), ], - values: &[&["olympic"], &["olympics"]], - range: 5..=6, + values: &[&["olympic"], &["olympics"], &["you"]], + range: 1..=6, }; static WORD_OX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32242,9 +61516,10 @@ pub static WORD_OX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("igen"), dictgen::InsensitiveStr::Ascii("imoron"), + dictgen::InsensitiveStr::Ascii("zillary"), ], - values: &[&["oxygen"], &["oxymoron"]], - range: 4..=6, + values: &[&["oxygen"], &["oxymoron"], &["auxiliary"]], + range: 4..=7, }; static WORD_OW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32254,17 +61529,45 @@ static WORD_OW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_OW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("erflow"), 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("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: &[ + &["overflow"], &["ownership"], &["overpowering"], + &["ownership"], + &["overwrite"], + &["overwrites"], + &["overwrite"], + &["overwrites"], + &["awful"], + &["owner"], &["wonders"], + &["ownership"], + &["owns", "ones"], + &["owner"], + &["onward"], + &["owner"], + &["ownership"], &["work"], &["would"], &["wouldve"], @@ -32295,17 +61598,80 @@ static WORD_OV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, + Some(&WORD_OVR_NODE), + Some(&WORD_OVS_NODE), None, None, - None, - 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: None, @@ -32316,14 +61682,14 @@ static WORD_OVE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, + Some(&WORD_OVEE_NODE), + Some(&WORD_OVEF_NODE), None, None, None, None, None, - None, - None, - None, + Some(&WORD_OVEL_NODE), None, None, None, @@ -32354,7 +61720,7 @@ static WORD_OVER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_OVERF_NODE), None, Some(&WORD_OVERH_NODE), - None, + Some(&WORD_OVERI_NODE), None, Some(&WORD_OVERK_NODE), Some(&WORD_OVERL_NODE), @@ -32396,6 +61762,7 @@ pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -32415,9 +61782,25 @@ pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("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: &[ @@ -32425,6 +61808,7 @@ pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["overwhelmed"], &["overwhelming"], &["overweight"], + &["overwhelm"], &["overwhelming"], &["overwhelmed"], &["overwhelmed"], @@ -32444,9 +61828,25 @@ pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["overwhelming"], &["overwhelmingly"], &["overweight"], + &["overview"], + &["overwrite"], + &["overwriting"], + &["overwritten"], + &["otherwise"], + &["overwrite"], + &["overwrites"], + &["overwritten"], + &["otherwise"], + &["overridden", "overwritten"], + &["overwrite"], + &["overwritable"], + &["overwritten"], + &["overwritten"], &["overwrite"], &["overwrite"], - &["overwrite"], + &["overwrites"], + &["overwriting"], + &["overwriting"], &["overwatch"], ], range: 3..=9, @@ -32458,9 +61858,25 @@ static WORD_OVERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_OVERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("locked")], - values: &[&["overclocked"]], - range: 6..=6, + 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 { @@ -32469,9 +61885,12 @@ static WORD_OVERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_OVERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("les")], - values: &[&["overuse"]], - range: 3..=3, + 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 { @@ -32522,6 +61941,10 @@ pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("implificiation"), dictgen::InsensitiveStr::Ascii("implifiction"), dictgen::InsensitiveStr::Ascii("implyfication"), + dictgen::InsensitiveStr::Ascii("ubscibe"), + dictgen::InsensitiveStr::Ascii("ubscibed"), + dictgen::InsensitiveStr::Ascii("ubscirbe"), + dictgen::InsensitiveStr::Ascii("ubscirbed"), dictgen::InsensitiveStr::Ascii("ue"), ], values: &[ @@ -32539,6 +61962,10 @@ pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["oversimplification"], &["oversimplification"], &["oversimplification"], + &["oversubscribe"], + &["oversubscribed"], + &["oversubscribe"], + &["oversubscribed"], &["overuse"], ], range: 2..=14, @@ -32556,7 +61983,28 @@ pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("idded"), + 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("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"), ], values: &[ &["overreacting"], @@ -32565,8 +62013,29 @@ pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["overreaction"], &["overreaction"], &["overridden"], + &["override"], + &["overrides"], + &["overridable"], + &["overridable"], + &["overridden"], + &["overrode", "overridden"], + &["overriding"], + &["overridable"], + &["overrode", "overridden"], + &["overridden"], + &["overridden"], + &["overriding"], + &["override", "ovary"], + &["overrides", "ovaries"], + &["overwrite", "override", "overrate"], + &["overridden"], + &["overridden"], + &["override"], + &["overridden"], + &["overrides"], + &["overriding"], ], - range: 4..=8, + range: 2..=8, }; static WORD_OVERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32642,43 +62111,61 @@ pub static WORD_OVERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("fow"), 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"), ], values: &[ &["overloaded"], &["overload"], &["overloaded"], + &["overlapped"], &["overlapping"], + &["overlap"], &["overlapping"], &["overlapping"], &["overloaded"], + &["overlaid"], &["overclock"], &["overclocked"], &["overclocking"], &["overlooking"], + &["overflow"], + &["overflow"], &["overload"], &["overload"], + &["overloaded"], + &["overloaded"], + &["overloads"], &["overlooking"], &["overlooked"], &["overloaded"], &["overlords"], &["overlords"], + &["overflow"], ], - range: 3..=7, + range: 2..=7, }; static WORD_OVERK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32695,6 +62182,31 @@ pub static WORD_OVERK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -32711,6 +62223,7 @@ pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -32729,6 +62242,7 @@ pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["overlooked"], &["overlooking"], &["overhyped"], + &["overhead"], &["overthinking"], &["overhaul"], &["overwhelm"], @@ -32746,9 +62260,13 @@ static WORD_OVERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_OVERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("apping")], - values: &[&["overlapping"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("apping"), + dictgen::InsensitiveStr::Ascii("l"), + dictgen::InsensitiveStr::Ascii("ow"), + ], + values: &[&["overlapping"], &["overflow"], &["overflow"]], + range: 1..=6, }; static WORD_OVERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32759,12 +62277,16 @@ static WORD_OVERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"], @@ -32813,6 +62335,12 @@ pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -32835,8 +62363,14 @@ pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["overcoming"], &["overcoming"], &["overcoming"], + &["overcompensate"], + &["overcompensated"], + &["overcompensates"], + &["overcompensating"], + &["overcompensation"], + &["overcompensations"], ], - range: 3..=7, + range: 3..=12, }; static WORD_OVERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -32868,154 +62402,706 @@ static WORD_OVERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_OVERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rcing")], - values: &[&["overarching"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("all"), + dictgen::InsensitiveStr::Ascii("rcing"), + ], + values: &[&["overall"], &["overarching"]], + range: 3..=5, }; -static WORD_OU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_OU_CHILDREN), +static WORD_OVEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_OVEL_CHILDREN), value: None, }; -pub static WORD_OU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_OVEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("ap")], + values: &[&["overlap"]], + range: 2..=2, +}; + +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("blisher"), - dictgen::InsensitiveStr::Ascii("evre"), - dictgen::InsensitiveStr::Ascii("put"), - dictgen::InsensitiveStr::Ascii("rselvs"), - dictgen::InsensitiveStr::Ascii("rsleves"), - dictgen::InsensitiveStr::Ascii("standing"), - dictgen::InsensitiveStr::Ascii("stider"), - dictgen::InsensitiveStr::Ascii("stiders"), - dictgen::InsensitiveStr::Ascii("stpoken"), - dictgen::InsensitiveStr::Ascii("tcalssed"), - dictgen::InsensitiveStr::Ascii("tclasssed"), - dictgen::InsensitiveStr::Ascii("tfeild"), - dictgen::InsensitiveStr::Ascii("tfidel"), - dictgen::InsensitiveStr::Ascii("tfied"), - dictgen::InsensitiveStr::Ascii("tfiled"), - dictgen::InsensitiveStr::Ascii("tisder"), - dictgen::InsensitiveStr::Ascii("tisders"), - dictgen::InsensitiveStr::Ascii("tlcassed"), - dictgen::InsensitiveStr::Ascii("tnumbed"), - dictgen::InsensitiveStr::Ascii("tnumberd"), - dictgen::InsensitiveStr::Ascii("tnumbred"), - dictgen::InsensitiveStr::Ascii("tnunbered"), - dictgen::InsensitiveStr::Ascii("tpalyed"), - dictgen::InsensitiveStr::Ascii("tperfom"), - dictgen::InsensitiveStr::Ascii("tperfoms"), - dictgen::InsensitiveStr::Ascii("tperfrom"), - dictgen::InsensitiveStr::Ascii("tperfroms"), - dictgen::InsensitiveStr::Ascii("tplayd"), - dictgen::InsensitiveStr::Ascii("tpreform"), - dictgen::InsensitiveStr::Ascii("tpreforms"), - dictgen::InsensitiveStr::Ascii("tpsoken"), - dictgen::InsensitiveStr::Ascii("tputed"), - dictgen::InsensitiveStr::Ascii("traegously"), - dictgen::InsensitiveStr::Ascii("trageos"), - dictgen::InsensitiveStr::Ascii("trageosly"), - dictgen::InsensitiveStr::Ascii("trageoulsy"), - dictgen::InsensitiveStr::Ascii("trageouly"), - dictgen::InsensitiveStr::Ascii("tragerous"), - dictgen::InsensitiveStr::Ascii("tragesouly"), - dictgen::InsensitiveStr::Ascii("trageuos"), - dictgen::InsensitiveStr::Ascii("trageuosly"), - dictgen::InsensitiveStr::Ascii("tragious"), - dictgen::InsensitiveStr::Ascii("tragiously"), - dictgen::InsensitiveStr::Ascii("tragoues"), - dictgen::InsensitiveStr::Ascii("treagous"), - dictgen::InsensitiveStr::Ascii("tsidr"), - dictgen::InsensitiveStr::Ascii("tskirst"), - dictgen::InsensitiveStr::Ascii("tskirters"), - dictgen::InsensitiveStr::Ascii("tskrits"), - dictgen::InsensitiveStr::Ascii("tsorucing"), - dictgen::InsensitiveStr::Ascii("tsourcad"), - dictgen::InsensitiveStr::Ascii("tsourcade"), - dictgen::InsensitiveStr::Ascii("tsourceing"), - dictgen::InsensitiveStr::Ascii("tsoure"), - dictgen::InsensitiveStr::Ascii("tsouring"), - dictgen::InsensitiveStr::Ascii("tsoursed"), - dictgen::InsensitiveStr::Ascii("tsoursing"), - dictgen::InsensitiveStr::Ascii("tweighes"), - dictgen::InsensitiveStr::Ascii("twieghs"), + dictgen::InsensitiveStr::Ascii("low"), + dictgen::InsensitiveStr::Ascii("lowed"), + dictgen::InsensitiveStr::Ascii("lowing"), + dictgen::InsensitiveStr::Ascii("lows"), ], values: &[ - &["publisher"], - &["oeuvre"], - &["output"], - &["ourselves"], - &["ourselves"], - &["outstanding"], - &["outsider"], - &["outsiders"], - &["outspoken"], - &["outclassed"], - &["outclassed"], - &["outfield"], - &["outfield"], - &["outfield"], - &["outfield"], - &["outsider"], - &["outsiders"], - &["outclassed"], - &["outnumbered"], - &["outnumbered"], - &["outnumbered"], - &["outnumbered"], - &["outplayed"], - &["outperform"], - &["outperform"], - &["outperform"], - &["outperform"], - &["outplayed"], - &["outperform"], - &["outperform"], - &["outspoken"], - &["outputted"], - &["outrageously"], - &["outrageous"], - &["outrageously"], - &["outrageously"], - &["outrageously"], - &["outrageous"], - &["outrageously"], - &["outrageous"], - &["outrageously"], - &["outrageous"], - &["outrageously"], - &["outrageous"], - &["outrageous"], - &["outsider"], - &["outskirts"], - &["outskirts"], - &["outskirts"], - &["outsourcing"], - &["outsourced"], - &["outsourced"], - &["outsourcing"], - &["outsourced"], - &["outsourcing"], - &["outsourced"], - &["outsourcing"], + &["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), + None, + None, + None, + None, + None, + None, +]; + +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: 3..=10, + 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("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"], + &["outsider"], + &["outskirts"], + &["outskirts"], + &["outskirts"], + &["outsourcing"], + &["outsourced"], + &["outsourced"], + &["outsourcing"], + &["outsourced"], + &["outsourcing"], + &["outsourced"], + &["outsourcing"], + ], + range: 3..=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("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"], + &["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("ut"), + ], + values: &[&["outgoing"], &["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("vre")], + values: &[&["oeuvre"]], + range: 3..=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::Flat(&WORD_OT_CHILDREN), - value: None, + value: Some(&["to", "of", "or"]), }; pub static WORD_OT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ain"), + dictgen::InsensitiveStr::Ascii("ained"), + dictgen::InsensitiveStr::Ascii("ains"), dictgen::InsensitiveStr::Ascii("ehr"), + dictgen::InsensitiveStr::Ascii("ehrwice"), + dictgen::InsensitiveStr::Ascii("ehrwise"), + dictgen::InsensitiveStr::Ascii("ehrwize"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("erwice"), + dictgen::InsensitiveStr::Ascii("erwise"), + dictgen::InsensitiveStr::Ascii("erwize"), + dictgen::InsensitiveStr::Ascii("he"), + dictgen::InsensitiveStr::Ascii("here"), + dictgen::InsensitiveStr::Ascii("herewise"), + dictgen::InsensitiveStr::Ascii("herise"), + dictgen::InsensitiveStr::Ascii("heriwse"), + dictgen::InsensitiveStr::Ascii("herwaise"), + dictgen::InsensitiveStr::Ascii("herways"), + dictgen::InsensitiveStr::Ascii("herweis"), + dictgen::InsensitiveStr::Ascii("herweise"), + dictgen::InsensitiveStr::Ascii("herwhere"), + dictgen::InsensitiveStr::Ascii("herwhile"), + dictgen::InsensitiveStr::Ascii("herwhise"), + dictgen::InsensitiveStr::Ascii("herwice"), + dictgen::InsensitiveStr::Ascii("herwide"), + dictgen::InsensitiveStr::Ascii("herwis"), + dictgen::InsensitiveStr::Ascii("herwize"), + dictgen::InsensitiveStr::Ascii("herwordly"), + dictgen::InsensitiveStr::Ascii("herwose"), + dictgen::InsensitiveStr::Ascii("herwrite"), + dictgen::InsensitiveStr::Ascii("herws"), + dictgen::InsensitiveStr::Ascii("herwse"), + dictgen::InsensitiveStr::Ascii("herwsie"), + dictgen::InsensitiveStr::Ascii("herwsise"), + dictgen::InsensitiveStr::Ascii("herwuise"), + dictgen::InsensitiveStr::Ascii("herwwise"), + dictgen::InsensitiveStr::Ascii("herwyse"), + dictgen::InsensitiveStr::Ascii("hewice"), + dictgen::InsensitiveStr::Ascii("hewise"), + dictgen::InsensitiveStr::Ascii("hewize"), + dictgen::InsensitiveStr::Ascii("ho"), + dictgen::InsensitiveStr::Ascii("hographic"), dictgen::InsensitiveStr::Ascii("hrodox"), + dictgen::InsensitiveStr::Ascii("hwerwise"), + dictgen::InsensitiveStr::Ascii("hwhise"), + dictgen::InsensitiveStr::Ascii("ification"), + dictgen::InsensitiveStr::Ascii("iginal"), + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("ional"), + dictgen::InsensitiveStr::Ascii("ions"), + dictgen::InsensitiveStr::Ascii("pion"), + dictgen::InsensitiveStr::Ascii("pions"), + dictgen::InsensitiveStr::Ascii("put"), + dictgen::InsensitiveStr::Ascii("u"), ], - values: &[&["other"], &["orthodox"]], - range: 3..=6, + values: &[ + &["obtain"], + &["obtained"], + &["obtains"], + &["other"], + &["otherwise"], + &["otherwise"], + &["otherwise"], + &["other", "otter"], + &["otherwise"], + &["otherwise"], + &["otherwise"], + &["other"], + &["other"], + &["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"], + &["notification"], + &["original"], + &["option"], + &["optional", "notional"], + &["options"], + &["option"], + &["options"], + &["output"], + &["out"], + ], + range: 1..=9, }; static WORD_OS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33026,6 +63112,16 @@ static WORD_OS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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"), @@ -33042,6 +63138,16 @@ pub static WORD_OS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg ], values: &[ &["obsidian"], + &["obscure"], + &["oscillator"], + &["oscillate"], + &["oscillated"], + &["oscillating"], + &["oscillator"], + &["offset"], + &["offsets"], + &["offsetting"], + &["oscillations"], &["ostensibly"], &["ostensibly"], &["ostensibly"], @@ -33056,7 +63162,7 @@ pub static WORD_OS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["ostracized"], &["ostracized"], ], - range: 6..=9, + range: 5..=10, }; static WORD_OR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33082,7 +63188,7 @@ static WORD_OR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_ORP_NODE), None, - None, + Some(&WORD_ORR_NODE), None, Some(&WORD_ORT_NODE), None, @@ -33099,9 +63205,36 @@ static WORD_ORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("hodx")], - values: &[&["orthodox"]], - range: 4..=4, + 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"), + ], + values: &[ + &["orthogonal"], + &["orthogonal"], + &["orthogonalize"], + &["orthodox"], + &["orthogonal"], + &["orthogonalize"], + &["orthogonal"], + ], + range: 4..=10, +}; + +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 { @@ -33112,10 +63245,21 @@ static WORD_ORP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["orphans"]], - range: 4..=5, + values: &[ + &["orphans"], + &["orphan"], + &["orphanage"], + &["orphaned"], + &["orphans"], + &["orphans"], + ], + range: 2..=5, }; static WORD_ORL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33130,80 +63274,254 @@ pub static WORD_ORL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_ORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ORI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ORI_CHILDREN), value: None, }; -pub static WORD_ORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_ORI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_ORIA_NODE), + Some(&WORD_ORIB_NODE), + None, + 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("btal"), - dictgen::InsensitiveStr::Ascii("dinarily"), - dictgen::InsensitiveStr::Ascii("dnary"), - dictgen::InsensitiveStr::Ascii("entacion"), - dictgen::InsensitiveStr::Ascii("entaion"), - dictgen::InsensitiveStr::Ascii("entarla"), - dictgen::InsensitiveStr::Ascii("entarlo"), - dictgen::InsensitiveStr::Ascii("entato"), - dictgen::InsensitiveStr::Ascii("ganaly"), - dictgen::InsensitiveStr::Ascii("gianlly"), - dictgen::InsensitiveStr::Ascii("ginales"), - dictgen::InsensitiveStr::Ascii("ginalet"), - dictgen::InsensitiveStr::Ascii("ginalis"), - dictgen::InsensitiveStr::Ascii("ginall"), - dictgen::InsensitiveStr::Ascii("ginallity"), - dictgen::InsensitiveStr::Ascii("ginalt"), - dictgen::InsensitiveStr::Ascii("ginalty"), - dictgen::InsensitiveStr::Ascii("ginaly"), - dictgen::InsensitiveStr::Ascii("ginas"), - dictgen::InsensitiveStr::Ascii("gines"), - dictgen::InsensitiveStr::Ascii("ginially"), - dictgen::InsensitiveStr::Ascii("ginnally"), - dictgen::InsensitiveStr::Ascii("ginsl"), - dictgen::InsensitiveStr::Ascii("gintea"), - dictgen::InsensitiveStr::Ascii("gional"), - dictgen::InsensitiveStr::Ascii("gnally"), - dictgen::InsensitiveStr::Ascii("gniality"), - dictgen::InsensitiveStr::Ascii("gnially"), - dictgen::InsensitiveStr::Ascii("gnials"), - dictgen::InsensitiveStr::Ascii("gniated"), - dictgen::InsensitiveStr::Ascii("gonally"), - dictgen::InsensitiveStr::Ascii("gonated"), + dictgen::InsensitiveStr::Ascii("gal"), + dictgen::InsensitiveStr::Ascii("gally"), + ], + values: &[&["original"], &["originally"]], + 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("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: &[ - &["orbital"], - &["ordinarily"], - &["ordinary"], - &["orientation"], - &["orientation"], - &["oriental"], - &["oriental"], - &["orientation"], + &["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"], - &["originality"], - &["originality"], - &["originality"], - &["originally"], - &["origins"], - &["origins"], &["originally"], + &["originated"], + &["originating"], + &["original"], + &["originate"], + &["originated"], + &["originates"], + &["originating"], + &["originating"], &["originally"], &["originals"], &["originate"], + &["origin"], &["original"], &["originally"], + &["origin"], + &["original"], + &["originally"], + &["original"], &["originality"], &["originally"], &["originals"], &["originated"], + &["original"], &["originally"], &["originated"], ], - range: 4..=9, + 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("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"), + ], + values: &[ + &["orientate"], + &["orientated"], + &["orientation"], + &["orientate", "orient", "ornate"], + &["orientation"], + &["orientation"], + &["orientation"], + &["oriental"], + &["oriental"], + &["orientated"], + &["orientation"], + &["oriented"], + &["orientation"], + &["oriented"], + &["oriented"], + ], + 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("inarily"), + dictgen::InsensitiveStr::Ascii("nary"), + ], + values: &[&["ordinal", "original"], &["ordinarily"], &["ordinary"]], + range: 4..=7, +}; + +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 { @@ -33214,11 +63532,12 @@ static WORD_ORH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), ], - values: &[&["orchestra"], &["orphans"], &["orthodox"]], - range: 4..=6, + values: &[&["orchestra"], &["orphan"], &["orphans"], &["orthodox"]], + range: 3..=6, }; static WORD_ORG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33276,26 +63595,76 @@ static WORD_ORGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[ - &["origin"], &["original"], &["originally"], + &["originals"], + &["origin", "organ"], + &["original"], + &["originally"], + &["originals"], &["organisation"], &["organisations"], + &["originate"], + &["originated"], + &["originates"], + &["originating"], &["organization"], &["organizational"], &["organizations"], - &["organize"], + &["original"], + &["originally"], + &["originals"], + &["originate"], + &["originated"], + &["originates"], + &["original"], + &["originals"], + &["organisation"], + &["organisations"], + &["organised"], + &["organization"], + &["organizations"], + &["organize", "organize"], + &["organized"], + &["origins", "organs"], + &["originx"], + &["originy"], ], range: 1..=10, }; @@ -33318,7 +63687,7 @@ static WORD_ORGA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_ORGAM_NODE), Some(&WORD_ORGAN_NODE), None, None, @@ -33446,6 +63815,8 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -33472,11 +63843,14 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -33492,6 +63866,7 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("zms"), dictgen::InsensitiveStr::Ascii("zors"), dictgen::InsensitiveStr::Ascii("ztion"), + dictgen::InsensitiveStr::Ascii("ztions"), dictgen::InsensitiveStr::Ascii("zuje"), ], values: &[ @@ -33502,6 +63877,8 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["organism"], &["organism"], &["organisation"], + &["organisations"], + &["organisation"], &["organise"], &["organisations"], &["organisations"], @@ -33527,12 +63904,15 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["organise"], &["organise"], &["organisation"], + &["organisations"], &["organise"], &["organise"], &["organization"], &["organizational"], &["organize"], &["organization"], + &["organizations"], + &["organization"], &["organizational"], &["organizer"], &["organizer"], @@ -33547,6 +63927,7 @@ pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["organism"], &["organizers"], &["organization"], + &["organizations"], &["organize"], ], range: 1..=10, @@ -33566,6 +63947,17 @@ pub static WORD_ORGANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -33614,10 +64006,18 @@ static WORD_ORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ORD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("erd"), dictgen::InsensitiveStr::Ascii("ianry"), dictgen::InsensitiveStr::Ascii("inarly"), + dictgen::InsensitiveStr::Ascii("ner"), + ], + values: &[ + &["ordered"], + &["ordered"], + &["ordinary"], + &["ordinary"], + &["order"], ], - values: &[&["ordered"], &["ordinary"], &["ordinary"]], range: 2..=6, }; @@ -33628,6 +64028,7 @@ static WORD_ORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("hastrated"), @@ -33639,6 +64040,7 @@ pub static WORD_ORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("histrated"), ], values: &[ + &["oracle"], &["oracles"], &["orchestra"], &["orchestrated"], @@ -33649,7 +64051,7 @@ pub static WORD_ORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["orchestra"], &["orchestrated"], ], - range: 4..=9, + range: 3..=9, }; static WORD_ORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33707,25 +64109,76 @@ static WORD_OP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_OPA_NODE), - None, + Some(&WORD_OPB_NODE), None, None, Some(&WORD_OPE_NODE), None, None, - None, + Some(&WORD_OPH_NODE), Some(&WORD_OPI_NODE), None, None, 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, + None, + None, +]; + +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"), + ], + values: &[ + &["populate", "opiate", "opulent"], + &["populates", "opiates"], + ], + 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, @@ -33734,59 +64187,207 @@ static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, ]; -static WORD_OPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_OPT_CHILDREN), +static WORD_OPTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_OPTO_CHILDREN), value: None, }; -pub static WORD_OPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_OPTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("halmic"), - dictgen::InsensitiveStr::Ascii("halmologist"), - dictgen::InsensitiveStr::Ascii("halmology"), - dictgen::InsensitiveStr::Ascii("hamologist"), - dictgen::InsensitiveStr::Ascii("imaal"), - dictgen::InsensitiveStr::Ascii("imim"), - dictgen::InsensitiveStr::Ascii("imisim"), - dictgen::InsensitiveStr::Ascii("imisitc"), - dictgen::InsensitiveStr::Ascii("imisitic"), - dictgen::InsensitiveStr::Ascii("imistc"), - dictgen::InsensitiveStr::Ascii("imistisch"), - dictgen::InsensitiveStr::Ascii("imizacion"), - dictgen::InsensitiveStr::Ascii("imizare"), - dictgen::InsensitiveStr::Ascii("imizate"), - dictgen::InsensitiveStr::Ascii("imizating"), - dictgen::InsensitiveStr::Ascii("imizaton"), - dictgen::InsensitiveStr::Ascii("imizied"), - dictgen::InsensitiveStr::Ascii("imziation"), - dictgen::InsensitiveStr::Ascii("inally"), - dictgen::InsensitiveStr::Ascii("mizations"), - dictgen::InsensitiveStr::Ascii("omism"), + dictgen::InsensitiveStr::Ascii("in"), + dictgen::InsensitiveStr::Ascii("ins"), + dictgen::InsensitiveStr::Ascii("mism"), + ], + values: &[&["option"], &["options"], &["optimism"]], + range: 2..=4, +}; + +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("miality"), + dictgen::InsensitiveStr::Ascii("mier"), + dictgen::InsensitiveStr::Ascii("mim"), + 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("myze"), + 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("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("onnaly"), + dictgen::InsensitiveStr::Ascii("onss"), + dictgen::InsensitiveStr::Ascii("os"), + dictgen::InsensitiveStr::Ascii("smied"), + dictgen::InsensitiveStr::Ascii("zmied"), + ], + values: &[ + &["optional"], + &["optimal"], + &["optimisation"], + &["optimization", "optimisation"], + &["optimization"], + &["optimality"], + &["optimizer", "optimiser"], + &["optimism"], + &["optimism"], + &["optimistic"], + &["optimistic"], + &["optimism"], + &["optimistic"], + &["optimistic"], + &["optimization"], + &["optimization"], + &["optimizing"], + &["optimize"], + &["optimize"], + &["optimization"], + &["optimization"], + &["optimize"], + &["optimizer"], + &["optimize"], + &["optimize"], + &["optimization"], + &["optimize"], + &["option"], + &["optional"], + &["optimally", "optionally"], + &["option"], + &["optional"], + &["option"], + &["optional"], + &["options"], + &["optional", "optionally"], + &["optionally"], + &["optionally"], + &["optionally"], + &["optional"], + &["options"], + &["optional"], + &["option"], + &["optional"], + &["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"], - &["optimal"], - &["optimism"], - &["optimism"], - &["optimistic"], - &["optimistic"], - &["optimistic"], - &["optimistic"], - &["optimization"], - &["optimize"], - &["optimize"], - &["optimization"], - &["optimization"], - &["optimize"], - &["optimization"], - &["optimally"], - &["optimizations"], - &["optimism"], ], - range: 4..=11, + 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 { @@ -33796,12 +64397,24 @@ static WORD_OPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_OPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("eating"), + dictgen::InsensitiveStr::Ascii("eation"), + dictgen::InsensitiveStr::Ascii("eations"), dictgen::InsensitiveStr::Ascii("ession"), dictgen::InsensitiveStr::Ascii("essive"), dictgen::InsensitiveStr::Ascii("hans"), ], - values: &[&["oppression"], &["oppressive"], &["orphans"]], - range: 4..=6, + values: &[ + &["operation"], + &["operating"], + &["operation"], + &["operations"], + &["oppression"], + &["oppressive"], + &["orphans"], + ], + range: 4..=7, }; static WORD_OPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33812,15 +64425,24 @@ static WORD_OPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_OPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("enly"), + 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("ortuniste"), + dictgen::InsensitiveStr::Ascii("ortunisticly"), + dictgen::InsensitiveStr::Ascii("ortunistly"), dictgen::InsensitiveStr::Ascii("ortunites"), + dictgen::InsensitiveStr::Ascii("ortunties"), dictgen::InsensitiveStr::Ascii("osiste"), dictgen::InsensitiveStr::Ascii("ositition"), dictgen::InsensitiveStr::Ascii("osits"), @@ -33833,18 +64455,31 @@ pub static WORD_OPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("urtunities"), + dictgen::InsensitiveStr::Ascii("urtunity"), ], values: &[ &["openly"], + &["operation"], + &["operational"], + &["operations"], + &["opportunist"], &["opportunities"], + &["opportunity"], &["opinion"], + &["opinions"], &["opponent"], &["opponent"], &["opponent"], &["opponent"], &["opponent"], &["opportunities"], + &["opportunistically"], + &["opportunistically"], + &["opportunities"], &["opportunities"], &["opposites"], &["opposition"], @@ -33858,9 +64493,13 @@ pub static WORD_OPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["oppression"], &["opportunities"], &["opportunity"], + &["approximate"], + &["oops"], + &["opposite"], &["opportunities"], + &["opportunity"], ], - range: 4..=10, + range: 1..=12, }; static WORD_OPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33871,21 +64510,40 @@ static WORD_OPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_OPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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: &[ &["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("egroup"), + dictgen::InsensitiveStr::Ascii("ssl"), + ], + values: &[&["open"], &["opengroup"], &["openssl"]], + range: 1..=6, +}; + static WORD_OPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_OPI_CHILDREN), value: None, @@ -33895,44 +64553,350 @@ pub static WORD_OPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("niones"), dictgen::InsensitiveStr::Ascii("noins"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("onally"), + dictgen::InsensitiveStr::Ascii("ons"), dictgen::InsensitiveStr::Ascii("tcal"), dictgen::InsensitiveStr::Ascii("tmal"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tons"), ], - values: &[&["opinions"], &["opinions"], &["optical"], &["optimal"]], - range: 4..=6, + values: &[ + &["opinions"], + &["opinions"], + &["option"], + &["optionally"], + &["options"], + &["optical"], + &["optimal"], + &["option"], + &["options"], + ], + range: 2..=6, }; -static WORD_OPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_OPE_CHILDREN), +static WORD_OPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_OPH_CHILDREN), value: None, }; -pub static WORD_OPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_OPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("an")], + values: &[&["orphan"]], + range: 2..=2, +}; + +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("ness"), - dictgen::InsensitiveStr::Ascii("racional"), - dictgen::InsensitiveStr::Ascii("rasional"), - dictgen::InsensitiveStr::Ascii("ratie"), - dictgen::InsensitiveStr::Ascii("ratings"), - dictgen::InsensitiveStr::Ascii("rationable"), - dictgen::InsensitiveStr::Ascii("rationel"), - dictgen::InsensitiveStr::Ascii("rationnal"), - dictgen::InsensitiveStr::Ascii("rativne"), - dictgen::InsensitiveStr::Ascii("rativos"), + dictgen::InsensitiveStr::Ascii("aand"), + dictgen::InsensitiveStr::Ascii("aands"), + dictgen::InsensitiveStr::Ascii("acional"), + dictgen::InsensitiveStr::Ascii("aion"), + 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("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("aton"), + dictgen::InsensitiveStr::Ascii("atons"), + dictgen::InsensitiveStr::Ascii("attion"), + dictgen::InsensitiveStr::Ascii("attions"), + dictgen::InsensitiveStr::Ascii("eation"), + dictgen::InsensitiveStr::Ascii("taion"), + dictgen::InsensitiveStr::Ascii("taions"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tional"), + dictgen::InsensitiveStr::Ascii("tions"), ], values: &[ - &["openness"], + &["operand"], + &["operands"], &["operational"], + &["operation"], + &["operation"], + &["operands"], + &["operator"], &["operational"], + &["operation"], + &["operations"], + &["operator"], &["operative"], &["operations"], + &["operation"], + &["operational"], + &["operation"], &["operational"], &["operational"], - &["operational"], + &["operator"], &["operative"], &["operations"], + &["operating"], + &["operation"], + &["operations"], + &["operation"], + &["operations"], + &["operation"], + &["operation"], + &["operations"], + &["operation"], + &["operational"], + &["operations"], ], - range: 4..=10, + range: 4..=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("brower"), + dictgen::InsensitiveStr::Ascii("eing"), + 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: &[ + &["openbrowser"], + &["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 { @@ -33941,9 +64905,32 @@ static WORD_OPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_OPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rtor")], - values: &[&["operator"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ctity"), + dictgen::InsensitiveStr::Ascii("cy"), + dictgen::InsensitiveStr::Ascii("gue"), + dictgen::InsensitiveStr::Ascii("rtor"), + dictgen::InsensitiveStr::Ascii("tque"), + ], + values: &[ + &["opacity"], + &["opacity"], + &["opaque"], + &["operator"], + &["opaque"], + ], + 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")], + values: &[&["commits"]], + range: 5..=5, }; static WORD_ON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -33956,39 +64943,87 @@ pub static WORD_ON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("atrio"), dictgen::InsensitiveStr::Ascii("baord"), dictgen::InsensitiveStr::Ascii("borad"), + dictgen::InsensitiveStr::Ascii("ces"), + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("ece"), + dictgen::InsensitiveStr::Ascii("eyway"), 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("mipotent"), dictgen::InsensitiveStr::Ascii("miscient"), + dictgen::InsensitiveStr::Ascii("oly"), dictgen::InsensitiveStr::Ascii("ot"), + dictgen::InsensitiveStr::Ascii("s"), 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("traio"), + dictgen::InsensitiveStr::Ascii("trolled"), dictgen::InsensitiveStr::Ascii("wership"), + dictgen::InsensitiveStr::Ascii("y"), dictgen::InsensitiveStr::Ascii("yl"), ], values: &[ &["ontario"], &["onboard"], &["onboard"], + &["ounces", "once", "ones"], + &["one"], + &["once"], + &["oneway"], &["gonewild"], + &["only"], + &["only"], + &["online", "only"], + &["online"], + &["only"], &["onslaught"], &["omnipotent"], &["omniscient"], - &["note"], - &["onslaught"], + &["only"], + &["note", "not"], + &["owns"], + &["onslaught"], + &["oneself"], + &["conservation", "observation"], &["onslaught"], &["onslaught"], &["onslaught"], + &["contain"], + &["contained"], + &["container"], + &["containers"], + &["containing"], + &["containing"], + &["container"], + &["containers"], + &["contains"], &["ontario"], &["ontario"], + &["controlled"], &["ownership"], &["only"], + &["only"], ], - range: 2..=8, + range: 1..=9, }; static WORD_OM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34003,10 +65038,14 @@ pub static WORD_OM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ision"), dictgen::InsensitiveStr::Ascii("ited"), dictgen::InsensitiveStr::Ascii("iting"), + dictgen::InsensitiveStr::Ascii("itt"), dictgen::InsensitiveStr::Ascii("lette"), 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"), @@ -34017,6 +65056,8 @@ pub static WORD_OM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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: &[ @@ -34025,10 +65066,14 @@ pub static WORD_OM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["omission"], &["omitted"], &["omitting"], + &["omit"], &["omelette"], &["omission"], + &["omission"], + &["omit"], &["omitted"], &["omitting"], + &["omits"], &["omitted"], &["omitting"], &["omnipotent"], @@ -34039,9 +65084,11 @@ pub static WORD_OM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["omnivorous"], &["omnivorously"], &["omniscient"], + &["implementation"], + &["implementation"], &["more"], ], - range: 2..=10, + range: 2..=12, }; static WORD_OL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34053,11 +65100,17 @@ pub static WORD_OL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -34066,17 +65119,61 @@ pub static WORD_OL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg values: &[ &["obligatory"], &["obliterated"], + &["oldest"], &["oligarchy"], &["oligarchy"], + &["all", "ole", "old", "olly", "oil"], &["olympic"], &["olympics"], + &["only"], &["orleans"], + &["old"], + &["other"], + &["only"], &["olympics"], &["olympics"], &["olympic"], &["olympics"], ], - range: 5..=9, + 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")], + values: &[&["okay"]], + range: 2..=2, +}; + +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 { @@ -34085,9 +65182,45 @@ static WORD_OI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_OI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lgarchy")], - values: &[&["oligarchy"]], - range: 7..=7, + 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("erwise"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("ters"), + dictgen::InsensitiveStr::Ascii("terwise"), + ], + values: &[&["otherwise"], &["other"], &["others"], &["otherwise"]], + range: 3..=7, }; static WORD_OG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34102,7 +65235,12 @@ pub static WORD_OG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ranisation"), dictgen::InsensitiveStr::Ascii("rilla"), ], - values: &[&["going"], &["oligarchy"], &["organisation"], &["gorilla"]], + values: &[ + &["going", "ogling"], + &["oligarchy"], + &["organisation"], + &["gorilla"], + ], range: 3..=10, }; @@ -34119,27 +65257,53 @@ pub static WORD_OF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("cousre"), dictgen::InsensitiveStr::Ascii("crouse"), dictgen::InsensitiveStr::Ascii("fcers"), + dictgen::InsensitiveStr::Ascii("fcial"), dictgen::InsensitiveStr::Ascii("fcially"), + dictgen::InsensitiveStr::Ascii("fcials"), dictgen::InsensitiveStr::Ascii("fensivelly"), dictgen::InsensitiveStr::Ascii("fensivley"), dictgen::InsensitiveStr::Ascii("fensivly"), + dictgen::InsensitiveStr::Ascii("ferd"), dictgen::InsensitiveStr::Ascii("fereings"), dictgen::InsensitiveStr::Ascii("fesnively"), + dictgen::InsensitiveStr::Ascii("fest"), + dictgen::InsensitiveStr::Ascii("fests"), + dictgen::InsensitiveStr::Ascii("fet"), + dictgen::InsensitiveStr::Ascii("fets"), + dictgen::InsensitiveStr::Ascii("fic"), dictgen::InsensitiveStr::Ascii("ficailly"), dictgen::InsensitiveStr::Ascii("fical"), dictgen::InsensitiveStr::Ascii("fically"), dictgen::InsensitiveStr::Ascii("ficals"), dictgen::InsensitiveStr::Ascii("ficaly"), + dictgen::InsensitiveStr::Ascii("ficeal"), + dictgen::InsensitiveStr::Ascii("ficeally"), + dictgen::InsensitiveStr::Ascii("ficeals"), + dictgen::InsensitiveStr::Ascii("ficealy"), dictgen::InsensitiveStr::Ascii("ficiallly"), dictgen::InsensitiveStr::Ascii("ficialy"), dictgen::InsensitiveStr::Ascii("fisde"), + dictgen::InsensitiveStr::Ascii("floded"), dictgen::InsensitiveStr::Ascii("fpsring"), dictgen::InsensitiveStr::Ascii("fred"), + dictgen::InsensitiveStr::Ascii("fser"), + dictgen::InsensitiveStr::Ascii("fseted"), + dictgen::InsensitiveStr::Ascii("fseting"), + dictgen::InsensitiveStr::Ascii("fsetp"), + dictgen::InsensitiveStr::Ascii("fsett"), dictgen::InsensitiveStr::Ascii("fsited"), dictgen::InsensitiveStr::Ascii("fspirng"), dictgen::InsensitiveStr::Ascii("fsrping"), + dictgen::InsensitiveStr::Ascii("fstets"), + dictgen::InsensitiveStr::Ascii("ften"), + dictgen::InsensitiveStr::Ascii("icial"), + dictgen::InsensitiveStr::Ascii("icially"), + dictgen::InsensitiveStr::Ascii("o"), dictgen::InsensitiveStr::Ascii("ocurse"), + dictgen::InsensitiveStr::Ascii("rom"), + dictgen::InsensitiveStr::Ascii("setted"), dictgen::InsensitiveStr::Ascii("tenly"), + dictgen::InsensitiveStr::Ascii("then"), ], values: &[ &["ofcourse"], @@ -34148,12 +65312,24 @@ pub static WORD_OF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["ofcourse"], &["ofcourse"], &["officers"], + &["official"], &["officially"], + &["officials"], &["offensively"], &["offensively"], &["offensively"], + &["offered"], &["offerings"], &["offensively"], + &["offset"], + &["offsets"], + &["offset", "offer"], + &["offsets", "offers"], + &["office"], + &["officially"], + &["official"], + &["officially"], + &["officials"], &["officially"], &["official"], &["officially"], @@ -34162,82 +65338,331 @@ pub static WORD_OF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["officially"], &["officially"], &["offside"], + &["offloaded"], &["offspring"], &["offered"], + &["offset"], + &["offsetted"], + &["offsetting"], + &["offset"], + &["offset"], &["offside"], &["offspring"], &["offspring"], + &["offsets"], + &["often"], + &["official"], + &["officially"], + &["of"], &["ofcourse"], + &["from"], + &["offsetted"], + &["often"], &["often"], ], - range: 4..=10, + range: 1..=10, }; -static WORD_OC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_OC_CHILDREN), +static WORD_OE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_OE_CHILDREN), value: None, }; -pub static WORD_OC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_OE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("arnia"), - dictgen::InsensitiveStr::Ascii("asion"), - dictgen::InsensitiveStr::Ascii("asional"), - dictgen::InsensitiveStr::Ascii("asionally"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("rflow"), + ], + values: &[&["one"], &["overflow"]], + range: 1..=5, +}; + +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("er"), + dictgen::InsensitiveStr::Ascii("ly"), + ], + values: &[&["order", "odor"], &["oddly"]], + range: 2..=2, +}; + +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, + None, + None, + None, + None, + None, + 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("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"), + ], + values: &[ + &["countries"], + &["country"], + &["occupied"], + &["occupies"], + &["occupy"], + &["occupying"], + &["occur"], + &["occur"], + &["occurrence"], + &["occurred"], + &["occurrence"], + &["occurrences"], + ], + 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("obear"), + dictgen::InsensitiveStr::Ascii("ohedra"), + dictgen::InsensitiveStr::Ascii("ohedral"), + dictgen::InsensitiveStr::Ascii("ohedron"), + dictgen::InsensitiveStr::Ascii("opuns"), + ], + values: &[ + &["octet"], + &["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_OCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_OCC_CHILDREN), + value: None, +}; + +pub static WORD_OCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("aison"), + dictgen::InsensitiveStr::Ascii("aisonal"), + dictgen::InsensitiveStr::Ascii("aisonally"), + dictgen::InsensitiveStr::Ascii("aisons"), + dictgen::InsensitiveStr::Ascii("asinal"), + dictgen::InsensitiveStr::Ascii("asinally"), + dictgen::InsensitiveStr::Ascii("asioanlly"), + dictgen::InsensitiveStr::Ascii("asionals"), dictgen::InsensitiveStr::Ascii("asionaly"), - dictgen::InsensitiveStr::Ascii("asioned"), - dictgen::InsensitiveStr::Ascii("asions"), + dictgen::InsensitiveStr::Ascii("asionly"), + dictgen::InsensitiveStr::Ascii("asionnal"), dictgen::InsensitiveStr::Ascii("assion"), dictgen::InsensitiveStr::Ascii("assional"), dictgen::InsensitiveStr::Ascii("assionally"), dictgen::InsensitiveStr::Ascii("assionaly"), dictgen::InsensitiveStr::Ascii("assioned"), dictgen::InsensitiveStr::Ascii("assions"), - dictgen::InsensitiveStr::Ascii("caison"), - dictgen::InsensitiveStr::Ascii("caisonal"), - dictgen::InsensitiveStr::Ascii("caisonally"), - dictgen::InsensitiveStr::Ascii("caisons"), - dictgen::InsensitiveStr::Ascii("casioanlly"), - dictgen::InsensitiveStr::Ascii("casionals"), - dictgen::InsensitiveStr::Ascii("casionaly"), - dictgen::InsensitiveStr::Ascii("casionly"), - dictgen::InsensitiveStr::Ascii("casionnal"), - dictgen::InsensitiveStr::Ascii("cassion"), - dictgen::InsensitiveStr::Ascii("cassional"), - dictgen::InsensitiveStr::Ascii("cassionally"), - dictgen::InsensitiveStr::Ascii("cassionaly"), - dictgen::InsensitiveStr::Ascii("cassioned"), - dictgen::InsensitiveStr::Ascii("cassions"), - dictgen::InsensitiveStr::Ascii("cational"), - dictgen::InsensitiveStr::Ascii("cationally"), - dictgen::InsensitiveStr::Ascii("cour"), - dictgen::InsensitiveStr::Ascii("culation"), - dictgen::InsensitiveStr::Ascii("cupaiton"), - dictgen::InsensitiveStr::Ascii("cupato"), - dictgen::InsensitiveStr::Ascii("curance"), - dictgen::InsensitiveStr::Ascii("curances"), + dictgen::InsensitiveStr::Ascii("ational"), + dictgen::InsensitiveStr::Ascii("ationally"), + dictgen::InsensitiveStr::Ascii("cur"), dictgen::InsensitiveStr::Ascii("cured"), - dictgen::InsensitiveStr::Ascii("curence"), - dictgen::InsensitiveStr::Ascii("curences"), - dictgen::InsensitiveStr::Ascii("curing"), - dictgen::InsensitiveStr::Ascii("curr"), - dictgen::InsensitiveStr::Ascii("currance"), - dictgen::InsensitiveStr::Ascii("currances"), - dictgen::InsensitiveStr::Ascii("currencies"), - dictgen::InsensitiveStr::Ascii("otber"), - dictgen::InsensitiveStr::Ascii("otpus"), - dictgen::InsensitiveStr::Ascii("raina"), - dictgen::InsensitiveStr::Ascii("tobear"), - dictgen::InsensitiveStr::Ascii("tohedra"), - dictgen::InsensitiveStr::Ascii("tohedral"), - dictgen::InsensitiveStr::Ascii("tohedron"), - dictgen::InsensitiveStr::Ascii("topuns"), - dictgen::InsensitiveStr::Ascii("untries"), - dictgen::InsensitiveStr::Ascii("untry"), + dictgen::InsensitiveStr::Ascii("curs"), + dictgen::InsensitiveStr::Ascii("our"), + dictgen::InsensitiveStr::Ascii("oured"), + dictgen::InsensitiveStr::Ascii("ouring"), + dictgen::InsensitiveStr::Ascii("ourring"), + dictgen::InsensitiveStr::Ascii("ours"), + dictgen::InsensitiveStr::Ascii("sionally"), + dictgen::InsensitiveStr::Ascii("ulation"), + dictgen::InsensitiveStr::Ascii("upaiton"), + dictgen::InsensitiveStr::Ascii("upato"), + dictgen::InsensitiveStr::Ascii("uped"), + dictgen::InsensitiveStr::Ascii("upided"), + dictgen::InsensitiveStr::Ascii("uracy"), + dictgen::InsensitiveStr::Ascii("urance"), + dictgen::InsensitiveStr::Ascii("urances"), + dictgen::InsensitiveStr::Ascii("urately"), + dictgen::InsensitiveStr::Ascii("urd"), + dictgen::InsensitiveStr::Ascii("urded"), + dictgen::InsensitiveStr::Ascii("ure"), + dictgen::InsensitiveStr::Ascii("ured"), + dictgen::InsensitiveStr::Ascii("urence"), + dictgen::InsensitiveStr::Ascii("urences"), + dictgen::InsensitiveStr::Ascii("ures"), + dictgen::InsensitiveStr::Ascii("uring"), dictgen::InsensitiveStr::Ascii("urr"), dictgen::InsensitiveStr::Ascii("urrance"), - dictgen::InsensitiveStr::Ascii("urred"), - dictgen::InsensitiveStr::Ascii("urrence"), + dictgen::InsensitiveStr::Ascii("urrances"), + dictgen::InsensitiveStr::Ascii("urrencies"), + dictgen::InsensitiveStr::Ascii("urrs"), + ], + values: &[ + &["occasion"], + &["occasional"], + &["occasionally"], + &["occasions"], + &["occasional"], + &["occasionally"], + &["occasionally"], + &["occasions"], + &["occasionally"], + &["occasional"], + &["occasional"], + &["occasion"], + &["occasional"], + &["occasionally"], + &["occasionally"], + &["occasioned"], + &["occasions"], + &["occasional"], + &["occasionally"], + &["occur"], + &["occurred"], + &["occurs"], + &["occur"], + &["occurred"], + &["occurring"], + &["occurring"], + &["occurs"], + &["occasionally"], + &["occupation"], + &["occupation"], + &["occupation"], + &["occupied"], + &["occupied"], + &["accuracy"], + &["occurrence"], + &["occurrences"], + &["accurately"], + &["occurred", "occur"], + &["occurred"], + &["occur", "occurred"], + &["occurred"], + &["occurrence"], + &["occurrences"], + &["occurs"], + &["occurring"], + &["occur"], + &["occurrence"], + &["occurrences"], + &["occurrences"], + &["occurs"], + ], + range: 3..=10, +}; + +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"], @@ -34253,53 +65678,8 @@ pub static WORD_OC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["occasionally"], &["occasioned"], &["occasions"], - &["occasion"], - &["occasional"], - &["occasionally"], - &["occasions"], - &["occasionally"], - &["occasions"], - &["occasionally"], - &["occasional"], - &["occasional"], - &["occasion"], - &["occasional"], - &["occasionally"], - &["occasionally"], - &["occasioned"], - &["occasions"], - &["occasional"], - &["occasionally"], - &["occur"], - &["occupation"], - &["occupation"], - &["occupation"], - &["occurrence"], - &["occurrences"], - &["occurred"], - &["occurrence"], - &["occurrences"], - &["occurring"], - &["occur"], - &["occurrence"], - &["occurrences"], - &["occurrences"], - &["october"], - &["octopus"], - &["ocarina"], - &["october"], - &["octahedra"], - &["octahedral"], - &["octahedron"], - &["octopus"], - &["countries"], - &["country"], - &["occur"], - &["occurrence"], - &["occurred"], - &["occurrence"], ], - range: 3..=11, + range: 4..=9, }; static WORD_OB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34314,28 +65694,42 @@ static WORD_OB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_OBD_NODE), Some(&WORD_OBE_NODE), None, - None, - None, + Some(&WORD_OBG_NODE), + Some(&WORD_OBH_NODE), Some(&WORD_OBI_NODE), Some(&WORD_OBJ_NODE), None, Some(&WORD_OBL_NODE), None, - None, + Some(&WORD_OBN_NODE), None, None, None, None, Some(&WORD_OBS_NODE), Some(&WORD_OBT_NODE), - None, + Some(&WORD_OBU_NODE), Some(&WORD_OBV_NODE), None, 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, @@ -34348,7 +65742,10 @@ pub static WORD_OBV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], @@ -34358,6 +65755,9 @@ pub static WORD_OBV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["oblivion"], &["obviously"], &["obviously"], + &["obvious"], + &["obviously"], + &["obvious"], &["obviously"], &["obvious"], &["obviously"], @@ -34365,6 +65765,17 @@ pub static WORD_OBV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -34372,20 +65783,38 @@ static WORD_OBT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("aineble"), dictgen::InsensitiveStr::Ascii("ainible"), + 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"], &["obtainable"], &["obtainable"], + &["obtain"], + &["obtained"], + &["obtains"], &["obtainable"], + &["obtain"], + &["obtained"], + &["obtains"], ], - range: 6..=7, + range: 4..=7, }; static WORD_OBS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34397,6 +65826,9 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("cruity"), dictgen::InsensitiveStr::Ascii("cuirty"), + dictgen::InsensitiveStr::Ascii("cur"), + dictgen::InsensitiveStr::Ascii("elete"), + dictgen::InsensitiveStr::Ascii("erv"), dictgen::InsensitiveStr::Ascii("ervabil"), dictgen::InsensitiveStr::Ascii("ervacion"), dictgen::InsensitiveStr::Ascii("ervaiton"), @@ -34414,7 +65846,15 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("olte"), + dictgen::InsensitiveStr::Ascii("olted"), dictgen::InsensitiveStr::Ascii("sesion"), dictgen::InsensitiveStr::Ascii("sesive"), dictgen::InsensitiveStr::Ascii("sessed"), @@ -34427,10 +65867,14 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("truktion"), dictgen::InsensitiveStr::Ascii("turction"), dictgen::InsensitiveStr::Ascii("ucrity"), + dictgen::InsensitiveStr::Ascii("ure"), ], values: &[ &["obscurity"], &["obscurity"], + &["obscure"], + &["obsolete"], + &["observe"], &["observable"], &["observation"], &["observant"], @@ -34448,7 +65892,15 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["obsessive"], &["obsession"], &["obsessive"], + &["observer"], + &["observers"], &["obsidian"], + &["obsolete"], + &["obsolescence"], + &["obsolete"], + &["obsoleted"], + &["obsolete"], + &["obsoleted"], &["obsession"], &["obsessive"], &["obsessed"], @@ -34461,8 +65913,20 @@ pub static WORD_OBS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["obstruction"], &["obstruction"], &["obscurity"], + &["obscure"], ], - range: 5..=8, + range: 3..=8, +}; + +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 { @@ -34482,6 +65946,7 @@ pub static WORD_OBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("iterared"), dictgen::InsensitiveStr::Ascii("itirated"), dictgen::InsensitiveStr::Ascii("itorated"), + dictgen::InsensitiveStr::Ascii("itque"), dictgen::InsensitiveStr::Ascii("iverated"), ], values: &[ @@ -34495,9 +65960,10 @@ pub static WORD_OBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["obliterated"], &["obliterated"], &["obliterated"], + &["oblique"], &["obliterated"], ], - range: 7..=8, + range: 5..=8, }; static WORD_OBJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34507,7 +65973,9 @@ static WORD_OBJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -34525,10 +65993,23 @@ pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -34546,9 +66027,20 @@ pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["objectives"], &["objectivity"], &["objectivity"], + &["objects"], + &["object"], + &["object"], &["objectives"], + &["object"], + &["object"], + &["objects"], + &["objects"], + &["obtain"], + &["obtained"], + &["obtains"], + &["objdump"], ], - range: 6..=13, + range: 2..=13, }; static WORD_OBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34562,6 +66054,8 @@ pub static WORD_OBI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -34571,11 +66065,56 @@ pub static WORD_OBI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["obligatory"], &["obliterated"], &["oblivion"], + &["obvious"], + &["obviously"], &["obsidian"], &["obvious"], &["obviously"], ], - range: 4..=8, + 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 { @@ -34585,30 +66124,38 @@ static WORD_OBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("jctives"), dictgen::InsensitiveStr::Ascii("rsvant"), dictgen::InsensitiveStr::Ascii("rsvation"), dictgen::InsensitiveStr::Ascii("rsvations"), dictgen::InsensitiveStr::Ascii("rsvers"), + dictgen::InsensitiveStr::Ascii("serve"), dictgen::InsensitiveStr::Ascii("ssion"), + dictgen::InsensitiveStr::Ascii("ssions"), dictgen::InsensitiveStr::Ascii("sssion"), ], values: &[ + &["object"], &["obedience"], &["obedient"], &["obedience"], + &["object"], &["objectives"], &["observant"], &["observation"], &["observations"], &["observers"], + &["observe"], &["obsession"], + &["obsessions"], &["obsession"], ], - range: 5..=9, + range: 2..=9, }; static WORD_OBD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34631,9 +66178,10 @@ pub static WORD_OBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("mination"), dictgen::InsensitiveStr::Ascii("tinable"), + dictgen::InsensitiveStr::Ascii("y"), ], - values: &[&["abomination"], &["obtainable"]], - range: 7..=8, + values: &[&["abomination"], &["obtainable"], &["obey"]], + range: 1..=8, }; static WORD_OA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34655,8 +66203,8 @@ static WORD_N_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_NA_NODE), None, - None, - None, + Some(&WORD_NC_NODE), + Some(&WORD_ND_NODE), Some(&WORD_NE_NODE), None, None, @@ -34666,7 +66214,7 @@ static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_NK_NODE), None, Some(&WORD_NM_NODE), - None, + Some(&WORD_NN_NODE), Some(&WORD_NO_NODE), None, None, @@ -34675,105 +66223,89 @@ static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_NT_NODE), Some(&WORD_NU_NODE), None, + Some(&WORD_NW_NODE), + None, + None, + None, +]; + +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_NU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_NU_CHILDREN), +static WORD_NUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_NUT_CHILDREN), value: None, }; -pub static WORD_NU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_NUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aghty"), - dictgen::InsensitiveStr::Ascii("atilus"), - dictgen::InsensitiveStr::Ascii("bmers"), - dictgen::InsensitiveStr::Ascii("celar"), - dictgen::InsensitiveStr::Ascii("celus"), - dictgen::InsensitiveStr::Ascii("clean"), - dictgen::InsensitiveStr::Ascii("clues"), - dictgen::InsensitiveStr::Ascii("cular"), - dictgen::InsensitiveStr::Ascii("culear"), - dictgen::InsensitiveStr::Ascii("erological"), - dictgen::InsensitiveStr::Ascii("erons"), - dictgen::InsensitiveStr::Ascii("eroscience"), - dictgen::InsensitiveStr::Ascii("etered"), - dictgen::InsensitiveStr::Ascii("etral"), - dictgen::InsensitiveStr::Ascii("etrality"), - dictgen::InsensitiveStr::Ascii("etron"), - dictgen::InsensitiveStr::Ascii("isanse"), - dictgen::InsensitiveStr::Ascii("lcear"), - dictgen::InsensitiveStr::Ascii("llabour"), - dictgen::InsensitiveStr::Ascii("llfiy"), - dictgen::InsensitiveStr::Ascii("llifiy"), - dictgen::InsensitiveStr::Ascii("mberous"), - dictgen::InsensitiveStr::Ascii("mercial"), - dictgen::InsensitiveStr::Ascii("mericable"), - dictgen::InsensitiveStr::Ascii("merious"), - dictgen::InsensitiveStr::Ascii("remburg"), - dictgen::InsensitiveStr::Ascii("rtient"), - dictgen::InsensitiveStr::Ascii("rtients"), - dictgen::InsensitiveStr::Ascii("rtitional"), - dictgen::InsensitiveStr::Ascii("saince"), - dictgen::InsensitiveStr::Ascii("sance"), - dictgen::InsensitiveStr::Ascii("siance"), - dictgen::InsensitiveStr::Ascii("tirent"), - dictgen::InsensitiveStr::Ascii("tirents"), - dictgen::InsensitiveStr::Ascii("treints"), - dictgen::InsensitiveStr::Ascii("tricional"), - dictgen::InsensitiveStr::Ascii("tricious"), - dictgen::InsensitiveStr::Ascii("triens"), - dictgen::InsensitiveStr::Ascii("trientes"), - dictgen::InsensitiveStr::Ascii("triet"), - dictgen::InsensitiveStr::Ascii("tritent"), - dictgen::InsensitiveStr::Ascii("tritents"), - dictgen::InsensitiveStr::Ascii("tritian"), - dictgen::InsensitiveStr::Ascii("tritinal"), - dictgen::InsensitiveStr::Ascii("tritionnal"), - dictgen::InsensitiveStr::Ascii("tritios"), - dictgen::InsensitiveStr::Ascii("tritiuos"), - dictgen::InsensitiveStr::Ascii("tritivos"), - dictgen::InsensitiveStr::Ascii("trituous"), - dictgen::InsensitiveStr::Ascii("trutional"), - dictgen::InsensitiveStr::Ascii("trutious"), - dictgen::InsensitiveStr::Ascii("turing"), + dictgen::InsensitiveStr::Ascii("irent"), + dictgen::InsensitiveStr::Ascii("irents"), + dictgen::InsensitiveStr::Ascii("reints"), + dictgen::InsensitiveStr::Ascii("ricional"), + dictgen::InsensitiveStr::Ascii("ricious"), + dictgen::InsensitiveStr::Ascii("riens"), + dictgen::InsensitiveStr::Ascii("rientes"), + 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: &[ - &["naughty"], - &["nautilus"], - &["numbers"], - &["nuclear"], - &["nucleus"], - &["unclean"], - &["nucleus"], - &["nuclear"], - &["nuclear"], - &["neurological"], - &["neurons"], - &["neuroscience"], - &["neutered"], - &["neutral"], - &["neutrality"], - &["neutron"], - &["nuisance"], - &["nuclear"], - &["nullarbor"], - &["nullify"], - &["nullify"], - &["numerous"], - &["numerical"], - &["numerical"], - &["numerous"], - &["nuremberg"], - &["nutrient"], - &["nutrients"], - &["nutritional"], - &["nuisance"], - &["nuisance"], - &["nuisance"], &["nutrient"], &["nutrients"], &["nutrients"], @@ -34795,7 +66327,257 @@ pub static WORD_NU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["nutritious"], &["nurturing"], ], - range: 5..=10, + range: 4..=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("tient"), + dictgen::InsensitiveStr::Ascii("tients"), + dictgen::InsensitiveStr::Ascii("titional"), + ], + values: &[ + &["nuremberg"], + &["nutrient"], + &["nutrients"], + &["nutritional"], + ], + range: 5..=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("beral"), + dictgen::InsensitiveStr::Ascii("berals"), + dictgen::InsensitiveStr::Ascii("beric"), + dictgen::InsensitiveStr::Ascii("berous"), + dictgen::InsensitiveStr::Ascii("bert"), + 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("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("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: &[ + &["numeral"], + &["numerals"], + &["numeric"], + &["numerous"], + &["number"], + &["numbers"], + &["numerate"], + &["numeration"], + &["number"], + &["numbering"], + &["numbers"], + &["number"], + &["numbers"], + &["number"], + &["numerator"], + &["numbering"], + &["numerical"], + &["numeral", "numerical"], + &["numerical"], + &["numbering"], + &["numerous"], + &["numbers"], + &["number"], + &["numbers"], + &["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("cear"), + dictgen::InsensitiveStr::Ascii("k"), + dictgen::InsensitiveStr::Ascii("labour"), + dictgen::InsensitiveStr::Ascii("lfiy"), + dictgen::InsensitiveStr::Ascii("lifiy"), + dictgen::InsensitiveStr::Ascii("ll"), + ], + values: &[ + &["nuclear"], + &["null"], + &["nullarbor"], + &["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("sanse"), + dictgen::InsensitiveStr::Ascii("ssance"), + ], + values: &[&["nuisance"], &["nuisance"]], + range: 5..=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 { @@ -34804,9 +66586,12 @@ static WORD_NT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_NT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("o")], - values: &[&["not"]], - range: 1..=1, + keys: &[ + dictgen::InsensitiveStr::Ascii("ification"), + dictgen::InsensitiveStr::Ascii("o"), + ], + values: &[&["notification"], &["not"]], + range: 1..=9, }; static WORD_NR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -34832,18 +66617,18 @@ static WORD_NO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_NOC_NODE), + Some(&WORD_NOD_NODE), + Some(&WORD_NOE_NODE), + Some(&WORD_NOF_NODE), None, - None, - None, - None, - None, - None, + Some(&WORD_NOH_NODE), + Some(&WORD_NOI_NODE), None, None, None, Some(&WORD_NOM_NODE), Some(&WORD_NON_NODE), - None, + Some(&WORD_NOO_NODE), None, None, Some(&WORD_NOR_NODE), @@ -34864,10 +66649,11 @@ static WORD_NOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), ], - values: &[&["nowadays"], &["now"]], + values: &[&["nowadays"], &["nowadays"], &["now"]], range: 1..=4, }; @@ -34880,65 +66666,273 @@ pub static WORD_NOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("eau"), dictgen::InsensitiveStr::Ascii("embeard"), + dictgen::InsensitiveStr::Ascii("emer"), dictgen::InsensitiveStr::Ascii("ermber"), dictgen::InsensitiveStr::Ascii("meber"), ], - values: &[&["nouveau"], &["november"], &["november"], &["november"]], + values: &[ + &["nouveau"], + &["november"], + &["november"], + &["november"], + &["november"], + ], range: 3..=7, }; static WORD_NOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_NOT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_NOT_CHILDREN), value: None, }; -pub static WORD_NOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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: &[], + values: &[], + range: 0..=0, +}; + +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("abley"), - dictgen::InsensitiveStr::Ascii("ablly"), - dictgen::InsensitiveStr::Ascii("acible"), - dictgen::InsensitiveStr::Ascii("ario"), - dictgen::InsensitiveStr::Ascii("ciable"), - dictgen::InsensitiveStr::Ascii("eable"), - dictgen::InsensitiveStr::Ascii("eably"), - dictgen::InsensitiveStr::Ascii("ebok"), - dictgen::InsensitiveStr::Ascii("eboook"), - dictgen::InsensitiveStr::Ascii("eriety"), - dictgen::InsensitiveStr::Ascii("eworhty"), - dictgen::InsensitiveStr::Ascii("eworthly"), - dictgen::InsensitiveStr::Ascii("eworty"), - dictgen::InsensitiveStr::Ascii("h"), - dictgen::InsensitiveStr::Ascii("hern"), - dictgen::InsensitiveStr::Ascii("hingess"), - dictgen::InsensitiveStr::Ascii("hingsness"), - dictgen::InsensitiveStr::Ascii("icabe"), - dictgen::InsensitiveStr::Ascii("icabely"), - dictgen::InsensitiveStr::Ascii("icable"), - dictgen::InsensitiveStr::Ascii("icabley"), - dictgen::InsensitiveStr::Ascii("icably"), - dictgen::InsensitiveStr::Ascii("icalbe"), - dictgen::InsensitiveStr::Ascii("iceablely"), - dictgen::InsensitiveStr::Ascii("iceabley"), - dictgen::InsensitiveStr::Ascii("iceing"), - dictgen::InsensitiveStr::Ascii("iciably"), - dictgen::InsensitiveStr::Ascii("icible"), - dictgen::InsensitiveStr::Ascii("ificacion"), - dictgen::InsensitiveStr::Ascii("ificaiton"), - dictgen::InsensitiveStr::Ascii("ificaitons"), - dictgen::InsensitiveStr::Ascii("ificaton"), - dictgen::InsensitiveStr::Ascii("ificatons"), - dictgen::InsensitiveStr::Ascii("orios"), - dictgen::InsensitiveStr::Ascii("oriosly"), - dictgen::InsensitiveStr::Ascii("oriuosly"), - dictgen::InsensitiveStr::Ascii("oroius"), - dictgen::InsensitiveStr::Ascii("whithstanding"), + dictgen::InsensitiveStr::Ascii("rios"), + dictgen::InsensitiveStr::Ascii("riosly"), + dictgen::InsensitiveStr::Ascii("riuosly"), + dictgen::InsensitiveStr::Ascii("roius"), + ], + values: &[ + &["notorious"], + &["notoriously"], + &["notoriously"], + &["notorious"], + ], + range: 4..=7, +}; + +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("dy"), + 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("ficacion"), + dictgen::InsensitiveStr::Ascii("ficaction"), + dictgen::InsensitiveStr::Ascii("ficaiton"), + dictgen::InsensitiveStr::Ascii("ficaitons"), + dictgen::InsensitiveStr::Ascii("ficaton"), + dictgen::InsensitiveStr::Ascii("ficatons"), + dictgen::InsensitiveStr::Ascii("ficiation"), + dictgen::InsensitiveStr::Ascii("fiy"), + dictgen::InsensitiveStr::Ascii("fiying"), + dictgen::InsensitiveStr::Ascii("fycation"), + dictgen::InsensitiveStr::Ascii("ty"), ], values: &[ - &["notably"], - &["notably"], &["noticeable"], - &["ontario"], + &["noticeably"], &["noticeable"], + &["noticeably"], + &["noticeably"], + &["noticeable"], + &["notification"], + &["notifications"], + &["noticeably"], + &["noticeably"], + &["noticing"], + &["noticeable"], + &["noticeably"], + &["noticeable"], + &["notify"], + &["notification"], + &["notifications"], + &["notification"], + &["notifications"], + &["notified"], + &["notifier"], + &["notifies"], + &["notification"], + &["notification"], + &["notification"], + &["notifications"], + &["notification"], + &["notifications"], + &["notification"], + &["notify"], + &["notifying"], + &["notification"], + &["notify"], + ], + range: 2..=9, +}; + +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("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"), + ], + values: &[ + &["northern"], + &["nothing"], + &["nothing"], + &["nothing"], + &["nothing"], + &["nothing"], + &["nothingness"], + &["nothingness"], + ], + range: 2..=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"), + ], + values: &[&["notification"], &["notifications"]], + range: 7..=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("riety"), + dictgen::InsensitiveStr::Ascii("worhty"), + dictgen::InsensitiveStr::Ascii("worthly"), + dictgen::InsensitiveStr::Ascii("worty"), + ], + values: &[ &["notable"], &["notably"], &["notebook"], @@ -34947,33 +66941,48 @@ pub static WORD_NOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["noteworthy"], &["noteworthy"], &["noteworthy"], - &["north"], - &["northern"], - &["nothingness"], - &["nothingness"], - &["noticeable"], - &["noticeably"], - &["noticeable"], - &["noticeably"], - &["noticeably"], - &["noticeable"], - &["noticeably"], - &["noticeably"], - &["noticing"], - &["noticeably"], - &["noticeable"], - &["notification"], - &["notification"], - &["notifications"], - &["notification"], - &["notifications"], - &["notorious"], - &["notoriously"], - &["notoriously"], - &["notorious"], - &["notwithstanding"], ], - range: 1..=13, + 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 { @@ -35024,20 +67033,50 @@ static WORD_NOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("theat"), dictgen::InsensitiveStr::Ascii("then"), dictgen::InsensitiveStr::Ascii("thereastern"), @@ -35047,25 +67086,56 @@ pub static WORD_NOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("thwesten"), dictgen::InsensitiveStr::Ascii("thwestener"), dictgen::InsensitiveStr::Ascii("thwet"), + 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"], &["northern"], &["northeast"], &["northern"], &["northwest"], &["northwestern"], + &["notifications"], + &["normalization"], + &["normalized"], + &["normal"], &["normals"], + &["normals"], + &["normal", "normally"], &["normalized"], &["normals"], &["normals"], &["normally"], + &["normally"], + &["normally"], + &["normalised"], + &["normally"], + &["normalization"], + &["normalize"], + &["normalized"], &["normandy"], &["normandy"], + &["normally"], + &["normal"], &["northeast"], &["northern"], &["northeastern"], @@ -35075,11 +67145,23 @@ pub static WORD_NOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["northwestern"], &["northwestern"], &["northwest"], + &["normally"], &["norwegian"], &["norwegian"], &["norwegian"], ], - range: 4..=11, + 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 { @@ -35090,31 +67172,41 @@ static WORD_NON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_NON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("combatents"), + 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("te"), dictgen::InsensitiveStr::Ascii("theless"), ], values: &[ &["noncombatants"], + &["nonexistence"], + &["nonexistent"], &["noninitial"], &["noninitialized"], + &["nonnegative"], &["nonsense"], &["nonsensical"], &["nonsensical"], &["nonsense"], + &["nonsense"], &["nonsensical"], &["nonsensical"], &["nonsense"], + &["note"], &["nonetheless"], ], - range: 4..=10, + range: 2..=10, }; static WORD_NOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35124,6 +67216,7 @@ static WORD_NOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_NOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("imal"), dictgen::InsensitiveStr::Ascii("inacion"), dictgen::InsensitiveStr::Ascii("inae"), dictgen::InsensitiveStr::Ascii("inatie"), @@ -35135,6 +67228,7 @@ pub static WORD_NOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("inet"), ], values: &[ + &["nominal"], &["nomination"], &["nominate"], &["nominate"], @@ -35148,6 +67242,69 @@ pub static WORD_NOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 4..=7, }; +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")], + values: &[&["noise", "nice", "notice"]], + range: 2..=2, +}; + +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"]), +}; + +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, @@ -35164,6 +67321,20 @@ pub static WORD_NOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("umber"), + ], + values: &[&["need"], &["number"]], + range: 2..=5, +}; + static WORD_NM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_NM_CHILDREN), value: None, @@ -35182,11 +67353,12 @@ static WORD_NK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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: &[&["know"], &["know"]], - range: 2..=2, + values: &[&["unknown"], &["know"], &["know"]], + range: 2..=4, }; static WORD_NI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35206,6 +67378,9 @@ pub static WORD_NI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("eghbourhood"), dictgen::InsensitiveStr::Ascii("eghbourhoods"), dictgen::InsensitiveStr::Ascii("eghbours"), + dictgen::InsensitiveStr::Ascii("ghbor"), + dictgen::InsensitiveStr::Ascii("ghborhood"), + dictgen::InsensitiveStr::Ascii("ghboring"), dictgen::InsensitiveStr::Ascii("ghlty"), dictgen::InsensitiveStr::Ascii("ghtime"), dictgen::InsensitiveStr::Ascii("ghtlcub"), @@ -35224,13 +67399,20 @@ pub static WORD_NI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("hilisim"), dictgen::InsensitiveStr::Ascii("hilsim"), dictgen::InsensitiveStr::Ascii("lihism"), + dictgen::InsensitiveStr::Ascii("mutes"), + dictgen::InsensitiveStr::Ascii("n"), dictgen::InsensitiveStr::Ascii("neth"), + dictgen::InsensitiveStr::Ascii("nima"), + dictgen::InsensitiveStr::Ascii("nimal"), + dictgen::InsensitiveStr::Ascii("nimum"), + dictgen::InsensitiveStr::Ascii("njs"), dictgen::InsensitiveStr::Ascii("nteenth"), dictgen::InsensitiveStr::Ascii("nties"), dictgen::InsensitiveStr::Ascii("nty"), dictgen::InsensitiveStr::Ascii("pticking"), dictgen::InsensitiveStr::Ascii("rtogen"), dictgen::InsensitiveStr::Ascii("rvanna"), + dictgen::InsensitiveStr::Ascii("ther"), dictgen::InsensitiveStr::Ascii("torgen"), dictgen::InsensitiveStr::Ascii("tpciking"), dictgen::InsensitiveStr::Ascii("usance"), @@ -35247,6 +67429,9 @@ pub static WORD_NI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["neighbourhood"], &["neighbourhood"], &["neighbours"], + &["neighbor"], + &["neighborhood"], + &["neighboring"], &["nightly"], &["nighttime"], &["nightclub"], @@ -35265,19 +67450,26 @@ pub static WORD_NI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["nihilism"], &["nihilism"], &["nihilism"], + &["minutes"], + &["inn", "min", "bin", "nine"], &["ninth"], + &["minima"], + &["minimal"], + &["minimum"], + &["ninja"], &["nineteenth"], - &["1990s"], - &["ninety"], + &["nineties"], + &["ninety", "minty"], &["nitpicking"], &["nitrogen"], &["nirvana"], + &["neither"], &["nitrogen"], &["nitpicking"], &["nuisance"], &["inverse"], ], - range: 3..=12, + range: 1..=12, }; static WORD_NE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35286,7 +67478,7 @@ static WORD_NE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_NEA_NODE), None, Some(&WORD_NEC_NODE), Some(&WORD_NED_NODE), @@ -35297,9 +67489,9 @@ static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_NEI_NODE), None, None, + Some(&WORD_NEL_NODE), None, - None, - None, + Some(&WORD_NEN_NODE), Some(&WORD_NEO_NODE), None, None, @@ -35326,10 +67518,15 @@ pub static WORD_NEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("castel"), dictgen::InsensitiveStr::Ascii("letters"), dictgen::InsensitiveStr::Ascii("lsetter"), + dictgen::InsensitiveStr::Ascii("ork"), + dictgen::InsensitiveStr::Ascii("orks"), 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"), ], values: &[ &["newcastle"], @@ -35337,12 +67534,17 @@ pub static WORD_NEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["newcastle"], &["newsletters"], &["newsletter"], + &["network"], + &["networks"], &["newsletter"], &["newsletter"], + &["newlines"], &["newspapers"], &["newspapers"], + &["newton"], + &["network"], ], - range: 5..=8, + range: 3..=8, }; static WORD_NEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35352,12 +67554,22 @@ static WORD_NEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_NEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[&["nevertheless"], &["nevertheless"], &["nevertheless"]], - range: 8..=9, + values: &[ + &["never"], + &["nevertheless"], + &["nevertheless"], + &["never"], + &["nevertheless"], + &["nevertheless"], + ], + range: 3..=10, }; static WORD_NEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35367,6 +67579,7 @@ static WORD_NEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_NEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("meric"), dictgen::InsensitiveStr::Ascii("orscience"), dictgen::InsensitiveStr::Ascii("ralogical"), dictgen::InsensitiveStr::Ascii("roligical"), @@ -35386,6 +67599,7 @@ pub static WORD_NEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("traly"), ], values: &[ + &["numeric"], &["neuroscience"], &["neurological"], &["neurological"], @@ -35414,30 +67628,50 @@ static WORD_NET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], - &["neutral"], + &["netscape"], + &["neutral", "natural"], &["neutrality"], &["neutron"], + &["netsplit"], &["network"], + &["networked"], &["networking"], + &["networks"], + &["network"], ], range: 4..=9, }; @@ -35449,13 +67683,46 @@ static WORD_NES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_NES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("seccary"), + dictgen::InsensitiveStr::Ascii("sesarily"), + dictgen::InsensitiveStr::Ascii("sesary"), + dictgen::InsensitiveStr::Ascii("sessarily"), + dictgen::InsensitiveStr::Ascii("sessary"), dictgen::InsensitiveStr::Ascii("tin"), + dictgen::InsensitiveStr::Ascii("twork"), ], - values: &[&["enslave"], &["necessarily"], &["necessary"], &["nesting"]], - range: 3..=8, + values: &[ + &["necessarily"], + &["necessary"], + &["necessarily"], + &["enslave"], + &["necessary"], + &["necessarily"], + &["necessary"], + &["necessarily"], + &["necessarily"], + &["necessary"], + &["necessary"], + &["necessary"], + &["necessarily"], + &["necessary"], + &["necessarily"], + &["necessary"], + &["nesting"], + &["network"], + ], + range: 3..=9, }; static WORD_NER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35469,14 +67736,16 @@ pub static WORD_NER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("uological"), dictgen::InsensitiveStr::Ascii("uons"), dictgen::InsensitiveStr::Ascii("uoscience"), + dictgen::InsensitiveStr::Ascii("ver"), ], values: &[ &["necromancer"], &["neurological"], &["neurons"], &["neuroscience"], + &["never"], ], - range: 4..=9, + range: 3..=9, }; static WORD_NEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35493,198 +67762,1760 @@ pub static WORD_NEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=9, }; -static WORD_NEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_NEI_CHILDREN), +static WORD_NEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_NEN_CHILDREN), value: None, }; -pub static WORD_NEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("ce"), - dictgen::InsensitiveStr::Ascii("gbhorhood"), - dictgen::InsensitiveStr::Ascii("gbhour"), - dictgen::InsensitiveStr::Ascii("gbhourhood"), - dictgen::InsensitiveStr::Ascii("gbhours"), - dictgen::InsensitiveStr::Ascii("gborhood"), - dictgen::InsensitiveStr::Ascii("gbour"), - dictgen::InsensitiveStr::Ascii("gbourhood"), - dictgen::InsensitiveStr::Ascii("gbouring"), - dictgen::InsensitiveStr::Ascii("gbours"), - dictgen::InsensitiveStr::Ascii("ghbhors"), - dictgen::InsensitiveStr::Ascii("ghboor"), - dictgen::InsensitiveStr::Ascii("ghboorhod"), - dictgen::InsensitiveStr::Ascii("ghboorhoud"), - dictgen::InsensitiveStr::Ascii("ghbords"), - dictgen::InsensitiveStr::Ascii("ghborehood"), - dictgen::InsensitiveStr::Ascii("ghbores"), - dictgen::InsensitiveStr::Ascii("ghborhing"), - dictgen::InsensitiveStr::Ascii("ghborhod"), - dictgen::InsensitiveStr::Ascii("ghborhods"), - dictgen::InsensitiveStr::Ascii("ghborhoood"), - dictgen::InsensitiveStr::Ascii("ghbourbood"), - dictgen::InsensitiveStr::Ascii("ghbourghs"), - dictgen::InsensitiveStr::Ascii("ghbourgood"), - dictgen::InsensitiveStr::Ascii("ghbourgs"), - dictgen::InsensitiveStr::Ascii("ghbourhod"), - dictgen::InsensitiveStr::Ascii("ghbourhoood"), - dictgen::InsensitiveStr::Ascii("ghbourhoud"), - dictgen::InsensitiveStr::Ascii("ghbourood"), - dictgen::InsensitiveStr::Ascii("ghbrohood"), - dictgen::InsensitiveStr::Ascii("ghourhood"), - dictgen::InsensitiveStr::Ascii("ghourhoods"), - dictgen::InsensitiveStr::Ascii("ghouring"), + 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: &[ - &["niece"], - &["neighborhoods"], - &["neighbour"], - &["neighbourhood"], - &["neighbours"], - &["neighborhood"], - &["neighbour"], - &["neighbourhood"], - &["neighbouring"], - &["neighbours"], - &["neighbors"], &["neighbor"], - &["neighbourhood"], - &["neighbourhood"], - &["neighbors"], &["neighborhood"], - &["neighbors"], + &["neighborhoods"], &["neighboring"], - &["neighborhood"], - &["neighborhoods"], - &["neighborhoods"], - &["neighbourhood"], - &["neighbours"], - &["neighbourhood"], - &["neighbours"], - &["neighbourhood"], - &["neighbourhood"], - &["neighbourhood"], - &["neighbourhood"], - &["neighborhoods"], + &["neighbors"], + &["neighbour"], &["neighbourhood"], &["neighbourhoods"], &["neighbouring"], + &["neighbours"], + &["neither"], + &["neighbor"], + &["neighborhood"], + &["neighborhoods"], + &["neighboring"], + &["neighbors"], ], - range: 2..=11, + range: 2..=9, }; -static WORD_NEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_NEG_CHILDREN), +static WORD_NEIGHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_NEIGHR_CHILDREN), value: None, }; -pub static WORD_NEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_NEIGHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("ativaty"), - dictgen::InsensitiveStr::Ascii("ativeity"), - dictgen::InsensitiveStr::Ascii("ativelly"), - dictgen::InsensitiveStr::Ascii("ativitiy"), - dictgen::InsensitiveStr::Ascii("ativley"), - dictgen::InsensitiveStr::Ascii("ativy"), - dictgen::InsensitiveStr::Ascii("elcting"), - dictgen::InsensitiveStr::Ascii("ilgence"), - dictgen::InsensitiveStr::Ascii("iotate"), - dictgen::InsensitiveStr::Ascii("iotated"), - dictgen::InsensitiveStr::Ascii("iotating"), - dictgen::InsensitiveStr::Ascii("lacting"), - dictgen::InsensitiveStr::Ascii("lagence"), - dictgen::InsensitiveStr::Ascii("lectn"), - dictgen::InsensitiveStr::Ascii("legance"), - dictgen::InsensitiveStr::Ascii("legible"), - dictgen::InsensitiveStr::Ascii("legting"), - dictgen::InsensitiveStr::Ascii("libible"), - dictgen::InsensitiveStr::Ascii("lible"), - dictgen::InsensitiveStr::Ascii("licence"), - dictgen::InsensitiveStr::Ascii("licible"), - dictgen::InsensitiveStr::Ascii("licting"), - dictgen::InsensitiveStr::Ascii("ligable"), - dictgen::InsensitiveStr::Ascii("ligance"), - dictgen::InsensitiveStr::Ascii("ligeble"), - dictgen::InsensitiveStr::Ascii("ligente"), - dictgen::InsensitiveStr::Ascii("ligiable"), - dictgen::InsensitiveStr::Ascii("ociate"), - dictgen::InsensitiveStr::Ascii("ociated"), - dictgen::InsensitiveStr::Ascii("ociating"), - dictgen::InsensitiveStr::Ascii("ociation"), - dictgen::InsensitiveStr::Ascii("ociations"), - dictgen::InsensitiveStr::Ascii("ogiated"), - dictgen::InsensitiveStr::Ascii("oitate"), - dictgen::InsensitiveStr::Ascii("oitated"), - dictgen::InsensitiveStr::Ascii("oitating"), - dictgen::InsensitiveStr::Ascii("oitation"), - dictgen::InsensitiveStr::Ascii("oitations"), - dictgen::InsensitiveStr::Ascii("otaited"), - dictgen::InsensitiveStr::Ascii("otation"), - dictgen::InsensitiveStr::Ascii("otiaion"), - dictgen::InsensitiveStr::Ascii("otiatians"), - dictgen::InsensitiveStr::Ascii("otiatie"), - dictgen::InsensitiveStr::Ascii("otiatied"), - dictgen::InsensitiveStr::Ascii("otiatiing"), - dictgen::InsensitiveStr::Ascii("otiatin"), - dictgen::InsensitiveStr::Ascii("otiationg"), - dictgen::InsensitiveStr::Ascii("otiatiors"), - dictgen::InsensitiveStr::Ascii("otiative"), - dictgen::InsensitiveStr::Ascii("otiaton"), - dictgen::InsensitiveStr::Ascii("otiatons"), + 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: &[ - &["negativity"], - &["negativity"], - &["negatively"], - &["negativity"], - &["negatively"], - &["negativity"], - &["neglecting"], - &["negligence"], - &["negotiate"], - &["negotiated"], - &["negotiating"], - &["neglecting"], - &["negligence"], - &["neglecting"], - &["negligence"], - &["negligible"], - &["neglecting"], - &["negligible"], - &["negligible"], - &["negligence"], - &["negligible"], - &["neglecting"], - &["negligible"], - &["negligence"], - &["negligible"], - &["negligence"], - &["negligible"], - &["negotiate"], - &["negotiated"], - &["negotiating"], - &["negotiation"], - &["negotiations"], - &["negotiated"], - &["negotiate"], - &["negotiated"], - &["negotiating"], - &["negotiation"], - &["negotiations"], - &["negotiated"], - &["negotiation"], - &["negotiation"], - &["negotiations"], - &["negotiated"], - &["negotiate"], - &["negotiating"], - &["negotiations"], - &["negotiating"], - &["negotiations"], - &["negotiate"], - &["negotiation"], - &["negotiations"], + &["neighbor"], + &["neighborhood"], + &["neighborhoods"], + &["neighboring"], + &["neighbors"], + &["neighbour"], + &["neighbourhood"], + &["neighbourhoods"], + &["neighbouring"], + &["neighbours"], ], - range: 5..=9, + 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("horhood"), + 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: &[ + &["neighborhoods"], + &["neighbour"], + &["neighbourhood"], + &["neighbours"], + &["neighbor"], + &["neighborhood"], + &["neighboring"], + &["neighbors"], + &["neighbour", "neighbour"], + &["neighbourhood"], + &["neighbouring", "neighbouring"], + &["neighbours", "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_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("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"], + &["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("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"], + &["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("tive"), + ], + values: &[ + &["negligible"], + &["negligence"], + &["negotiate"], + &["negotiated"], + &["negotiating"], + &["negative"], + ], + range: 3..=7, +}; + +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 { @@ -35705,31 +69536,79 @@ static WORD_NEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("s"), + dictgen::InsensitiveStr::Ascii("sd"), + dictgen::InsensitiveStr::Ascii("sds"), + dictgen::InsensitiveStr::Ascii("t"), ], values: &[ + &["needed", "need"], + &["needed"], &["needles"], &["needles"], &["needlessly"], &["needlessly"], &["needlessly"], + &["need"], + &["needed"], + &["needing"], + &["needle"], + &["needles", "needless"], + &["needless", "needles"], + &["needs"], + &["needs"], + &["needs"], + &["needs"], + &["need", "neat"], ], - range: 4..=8, + range: 1..=8, }; static WORD_NED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_NED_CHILDREN), - value: None, + value: Some(&["need"]), }; pub static WORD_NED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lessly")], - values: &[&["endlessly"]], - range: 6..=6, + 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"), + ], + values: &[ + &["need"], + &["needed"], + &["needed"], + &["media"], + &["medium"], + &["mediums"], + &["needle"], + &["needles", "needless"], + &["needless", "needles"], + &["endlessly"], + ], + range: 1..=6, }; static WORD_NEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35739,27 +69618,45 @@ static WORD_NEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_NEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("assery"), + dictgen::InsensitiveStr::Ascii("assry"), + dictgen::InsensitiveStr::Ascii("ause"), + dictgen::InsensitiveStr::Ascii("cecarily"), + dictgen::InsensitiveStr::Ascii("cecary"), dictgen::InsensitiveStr::Ascii("cesarily"), dictgen::InsensitiveStr::Ascii("cesary"), dictgen::InsensitiveStr::Ascii("cessarily"), + dictgen::InsensitiveStr::Ascii("cessarry"), dictgen::InsensitiveStr::Ascii("cessary"), dictgen::InsensitiveStr::Ascii("cessities"), + dictgen::InsensitiveStr::Ascii("cisary"), + dictgen::InsensitiveStr::Ascii("csessary"), dictgen::InsensitiveStr::Ascii("esarily"), + dictgen::InsensitiveStr::Ascii("esarrily"), + dictgen::InsensitiveStr::Ascii("esarry"), dictgen::InsensitiveStr::Ascii("esary"), + dictgen::InsensitiveStr::Ascii("essaery"), dictgen::InsensitiveStr::Ascii("essairly"), dictgen::InsensitiveStr::Ascii("essairy"), + dictgen::InsensitiveStr::Ascii("essar"), dictgen::InsensitiveStr::Ascii("essarilly"), + dictgen::InsensitiveStr::Ascii("essariy"), dictgen::InsensitiveStr::Ascii("essarly"), dictgen::InsensitiveStr::Ascii("essarry"), + dictgen::InsensitiveStr::Ascii("essaryly"), dictgen::InsensitiveStr::Ascii("essaties"), + dictgen::InsensitiveStr::Ascii("essay"), dictgen::InsensitiveStr::Ascii("esseraly"), dictgen::InsensitiveStr::Ascii("esserily"), + dictgen::InsensitiveStr::Ascii("essery"), + dictgen::InsensitiveStr::Ascii("essesary"), dictgen::InsensitiveStr::Ascii("essiate"), dictgen::InsensitiveStr::Ascii("essiates"), dictgen::InsensitiveStr::Ascii("essite"), dictgen::InsensitiveStr::Ascii("essites"), dictgen::InsensitiveStr::Ascii("essitites"), dictgen::InsensitiveStr::Ascii("essitive"), + dictgen::InsensitiveStr::Ascii("hanism"), dictgen::InsensitiveStr::Ascii("kbead"), dictgen::InsensitiveStr::Ascii("kbearders"), dictgen::InsensitiveStr::Ascii("kbeardese"), @@ -35781,30 +69678,49 @@ pub static WORD_NEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("romaner"), dictgen::InsensitiveStr::Ascii("romanser"), dictgen::InsensitiveStr::Ascii("romencer"), + dictgen::InsensitiveStr::Ascii("ssary"), dictgen::InsensitiveStr::Ascii("tode"), ], values: &[ + &["necessary"], + &["necessary"], + &["because"], &["necessarily"], &["necessary"], &["necessarily"], &["necessary"], - &["necessities"], - &["necessarily"], - &["necessary"], - &["necessarily"], - &["necessarily"], &["necessarily"], &["necessary"], &["necessary"], &["necessities"], + &["necessary"], + &["necessary"], &["necessarily"], &["necessarily"], + &["necessary"], + &["necessary"], + &["necessary"], + &["necessarily"], + &["necessarily"], + &["necessary"], + &["necessarily"], + &["necessary", "necessarily"], + &["necessary"], + &["necessary"], + &["necessarily"], + &["necessities"], + &["necessary"], + &["necessarily"], + &["necessarily"], + &["necessary"], + &["necessary"], &["necessitate"], &["necessities"], &["necessities"], &["necessities"], &["necessities"], &["necessities"], + &["mechanism"], &["neckbeard"], &["neckbeards"], &["neckbeards"], @@ -35826,11 +69742,61 @@ pub static WORD_NEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["necromancer"], &["necromancer"], &["necromancer"], + &["necessary"], &["netcode"], ], range: 4..=13, }; +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("gtive"), + dictgen::InsensitiveStr::Ascii("ly"), + dictgen::InsensitiveStr::Ascii("res"), + dictgen::InsensitiveStr::Ascii("rset"), + dictgen::InsensitiveStr::Ascii("st"), + ], + values: &[ + &["need"], + &["needed", "kneaded"], + &["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: &[], + values: &[], + range: 0..=0, +}; + +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("lude")], + values: &[&["include"]], + range: 4..=4, +}; + static WORD_NA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_NA_CHILDREN), value: None, @@ -35840,8 +69806,8 @@ static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_NAC_NODE), - None, - None, + Some(&WORD_NAD_NODE), + Some(&WORD_NAE_NODE), Some(&WORD_NAF_NODE), Some(&WORD_NAG_NODE), Some(&WORD_NAH_NODE), @@ -35849,8 +69815,8 @@ static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, - None, + Some(&WORD_NAM_NODE), + Some(&WORD_NAN_NODE), Some(&WORD_NAO_NODE), Some(&WORD_NAP_NODE), None, @@ -35860,7 +69826,7 @@ static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_NAU_NODE), Some(&WORD_NAV_NODE), None, - None, + Some(&WORD_NAX_NODE), None, Some(&WORD_NAZ_NODE), ]; @@ -35879,6 +69845,21 @@ pub static WORD_NAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=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_NAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_NAV_CHILDREN), value: None, @@ -35886,6 +69867,10 @@ static WORD_NAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("iagte"), dictgen::InsensitiveStr::Ascii("iagting"), dictgen::InsensitiveStr::Ascii("iagtion"), @@ -35895,6 +69880,10 @@ pub static WORD_NAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("igatore"), ], values: &[ + &["navigate"], + &["navigating"], + &["navigation"], + &["navigation"], &["navigate"], &["navigating"], &["navigation"], @@ -35903,7 +69892,7 @@ pub static WORD_NAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["navigation"], &["navigate"], ], - range: 5..=7, + range: 5..=9, }; static WORD_NAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -35936,7 +69925,7 @@ pub static WORD_NAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["nautilus"], &["nautilus"], &["nautilus"], - &["natural"], + &["natural", "neutral"], &["natures"], &["nautilus"], ], @@ -36008,6 +69997,7 @@ pub static WORD_NAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("urens"), dictgen::InsensitiveStr::Ascii("urual"), dictgen::InsensitiveStr::Ascii("urually"), + dictgen::InsensitiveStr::Ascii("vigation"), ], values: &[ &["natively"], @@ -36068,6 +70058,7 @@ pub static WORD_NAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["natures"], &["natural"], &["naturally"], + &["navigation"], ], range: 4..=13, }; @@ -36082,6 +70073,8 @@ pub static WORD_NAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("euous"), dictgen::InsensitiveStr::Ascii("hvile"), dictgen::InsensitiveStr::Ascii("hvillle"), + dictgen::InsensitiveStr::Ascii("tly"), + dictgen::InsensitiveStr::Ascii("tyness"), dictgen::InsensitiveStr::Ascii("ueous"), dictgen::InsensitiveStr::Ascii("vhille"), ], @@ -36089,10 +70082,12 @@ pub static WORD_NAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["nauseous"], &["nashville"], &["nashville"], + &["nasty"], + &["nastiness"], &["nauseous"], &["nashville"], ], - range: 5..=7, + range: 3..=7, }; static WORD_NAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36238,6 +70233,70 @@ pub static WORD_NAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("osencond"), + dictgen::InsensitiveStr::Ascii("osenconds"), + dictgen::InsensitiveStr::Ascii("oseond"), + dictgen::InsensitiveStr::Ascii("oseonds"), + ], + values: &[ + &["name"], + &["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: None, +}; + +pub static WORD_NAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("emespace"), + dictgen::InsensitiveStr::Ascii("epace"), + dictgen::InsensitiveStr::Ascii("epsace"), + dictgen::InsensitiveStr::Ascii("epsaces"), + dictgen::InsensitiveStr::Ascii("esd"), + 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"), + ], + values: &[ + &["named", "name"], + &["namespace"], + &["namespace"], + &["namespace"], + &["namespaces"], + &["named", "names"], + &["namespaces"], + &["name"], + &["name"], + &["named"], + &["names"], + &["namespace"], + &["namespaces"], + &["names"], + ], + range: 1..=8, +}; + static WORD_NAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_NAI_CHILDREN), value: None, @@ -36267,11 +70326,21 @@ static WORD_NAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["navigate"], &["navigating"], &["navigation"]], + values: &[ + &["negative"], + &["negatively"], + &["negatives"], + &["navigate"], + &["navigating"], + &["navigation"], + ], range: 5..=7, }; @@ -36286,6 +70355,28 @@ pub static WORD_NAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -36316,17 +70407,17 @@ static WORD_M_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_MH_NODE), Some(&WORD_MI_NODE), - None, + Some(&WORD_MJ_NODE), Some(&WORD_MK_NODE), None, - None, - None, + Some(&WORD_MM_NODE), + Some(&WORD_MN_NODE), Some(&WORD_MO_NODE), None, None, Some(&WORD_MR_NODE), Some(&WORD_MS_NODE), - None, + Some(&WORD_MT_NODE), Some(&WORD_MU_NODE), None, None, @@ -36342,12 +70433,24 @@ static WORD_MY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -36362,15 +70465,29 @@ pub static WORD_MY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("steris"), dictgen::InsensitiveStr::Ascii("sterise"), dictgen::InsensitiveStr::Ascii("sterous"), + dictgen::InsensitiveStr::Ascii("stql"), 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"], @@ -36385,9 +70502,11 @@ pub static WORD_MY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["mysteries"], &["mysteries"], &["mysterious"], + &["mysql"], &["mithraic"], + &["my"], ], - range: 3..=10, + range: 1..=10, }; static WORD_MU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36408,7 +70527,7 @@ static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_MUK_NODE), Some(&WORD_MUL_NODE), - None, + Some(&WORD_MUM_NODE), Some(&WORD_MUN_NODE), None, None, @@ -36420,10 +70539,21 @@ static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> 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, @@ -36431,52 +70561,102 @@ static WORD_MUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("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"], + &["much"], + &["matches"], + &["mutexes"], + &["mutexes"], + &["multi"], &["mutilated"], &["mutilation"], + &["multicast"], + &["mutexes"], + &["multiindex"], &["mutilation"], + &["multicast"], &["mutilated"], + &["multimarked"], + &["multipath"], + &["multiple", "multiply"], + &["multiple"], + &["multiply"], + &["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: 4..=11, + range: 1..=11, }; static WORD_MUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36486,6 +70666,7 @@ static WORD_MUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cels"), dictgen::InsensitiveStr::Ascii("cial"), dictgen::InsensitiveStr::Ascii("cially"), dictgen::InsensitiveStr::Ascii("cician"), @@ -36502,10 +70683,13 @@ pub static WORD_MUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("icaly"), dictgen::InsensitiveStr::Ascii("ilms"), dictgen::InsensitiveStr::Ascii("lces"), + dictgen::InsensitiveStr::Ascii("tator"), + dictgen::InsensitiveStr::Ascii("te"), dictgen::InsensitiveStr::Ascii("uclar"), dictgen::InsensitiveStr::Ascii("uems"), ], values: &[ + &["mussels", "muscles"], &["musical"], &["musically"], &["musician"], @@ -36522,10 +70706,12 @@ pub static WORD_MUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["musically"], &["muslims"], &["muscles"], + &["mutator"], + &["must"], &["muscular"], &["museums"], ], - range: 4..=8, + range: 2..=8, }; static WORD_MUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36569,8 +70755,10 @@ pub static WORD_MUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -36580,125 +70768,359 @@ pub static WORD_MUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["mundane"], &["mundane"], &["munchies"], + &["municipal"], &["manipulative"], &["municipality"], + &["minute"], ], - range: 4..=10, + range: 3..=10, }; -static WORD_MUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MUL_CHILDREN), +static WORD_MUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_MUM_CHILDREN), value: None, }; -pub static WORD_MUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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: None, +}; + +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("le"), + 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"], + &["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("iple"), - dictgen::InsensitiveStr::Ascii("itated"), - dictgen::InsensitiveStr::Ascii("itation"), - dictgen::InsensitiveStr::Ascii("itnational"), - dictgen::InsensitiveStr::Ascii("itnationals"), - dictgen::InsensitiveStr::Ascii("itplayer"), - dictgen::InsensitiveStr::Ascii("itple"), - dictgen::InsensitiveStr::Ascii("itples"), - dictgen::InsensitiveStr::Ascii("itplication"), - dictgen::InsensitiveStr::Ascii("itplied"), - dictgen::InsensitiveStr::Ascii("itplier"), - dictgen::InsensitiveStr::Ascii("itply"), - dictgen::InsensitiveStr::Ascii("itplying"), - dictgen::InsensitiveStr::Ascii("ittasking"), - dictgen::InsensitiveStr::Ascii("itverse"), - dictgen::InsensitiveStr::Ascii("sims"), - dictgen::InsensitiveStr::Ascii("ticultralism"), - dictgen::InsensitiveStr::Ascii("tilpier"), - dictgen::InsensitiveStr::Ascii("timational"), - dictgen::InsensitiveStr::Ascii("tinatinal"), - dictgen::InsensitiveStr::Ascii("tinationella"), - dictgen::InsensitiveStr::Ascii("tipalyer"), - dictgen::InsensitiveStr::Ascii("tipe"), - dictgen::InsensitiveStr::Ascii("tiplaer"), - dictgen::InsensitiveStr::Ascii("tiplater"), - dictgen::InsensitiveStr::Ascii("tiplaye"), - dictgen::InsensitiveStr::Ascii("tiplayr"), - dictgen::InsensitiveStr::Ascii("tiplays"), - dictgen::InsensitiveStr::Ascii("tiplebgs"), - dictgen::InsensitiveStr::Ascii("tipled"), - dictgen::InsensitiveStr::Ascii("tipleies"), - dictgen::InsensitiveStr::Ascii("tipleye"), - dictgen::InsensitiveStr::Ascii("tiplicacion"), - dictgen::InsensitiveStr::Ascii("tiplicaiton"), - dictgen::InsensitiveStr::Ascii("tiplicativo"), - dictgen::InsensitiveStr::Ascii("tiplicaton"), - dictgen::InsensitiveStr::Ascii("tiplikation"), - dictgen::InsensitiveStr::Ascii("tipling"), - dictgen::InsensitiveStr::Ascii("tiplr"), - dictgen::InsensitiveStr::Ascii("tipls"), - dictgen::InsensitiveStr::Ascii("tiplyed"), - dictgen::InsensitiveStr::Ascii("tiplyer"), - dictgen::InsensitiveStr::Ascii("tiplyng"), - dictgen::InsensitiveStr::Ascii("tipy"), - dictgen::InsensitiveStr::Ascii("titaksing"), - dictgen::InsensitiveStr::Ascii("titaskng"), - dictgen::InsensitiveStr::Ascii("titudine"), - dictgen::InsensitiveStr::Ascii("tiverese"), - dictgen::InsensitiveStr::Ascii("tplies"), - dictgen::InsensitiveStr::Ascii("typlayer"), - dictgen::InsensitiveStr::Ascii("typlying"), + 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: &[ + &["multiple"], + &["multiples"], + &["multiplied"], + &["multiplier"], + &["multipliers"], + &["multiplies"], + &["multiply"], + &["multiplying"], + ], + range: 4..=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("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("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"], + &["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"], + &["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("ple"), + dictgen::InsensitiveStr::Ascii("tated"), + dictgen::InsensitiveStr::Ascii("tation"), + dictgen::InsensitiveStr::Ascii("thread"), + 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: &[ &["multiple"], &["mutilated"], &["mutilation"], + &["multithread"], &["multinational"], &["multinational"], + &["multipart"], + &["multipath"], &["multiplayer"], &["multiple"], &["multiples"], &["multiplication"], + &["multiplicative"], &["multiplied"], &["multiplier"], + &["multipliers"], &["multiply"], &["multiplying"], &["multitasking"], &["multiverse"], - &["muslims"], - &["multiculturalism"], - &["multiplier"], - &["multinational"], - &["multinational"], - &["multinational"], - &["multiplayer"], - &["multiple"], - &["multiplier"], - &["multiplayer"], - &["multiply"], - &["multiply"], - &["multiply"], - &["multiples"], - &["multiplied"], - &["multiples"], - &["multiply"], - &["multiplication"], - &["multiplication"], - &["multiplication"], - &["multiplication"], - &["multiplication"], - &["multiplying"], - &["multiplier"], - &["multiples"], - &["multiplied"], - &["multiple"], - &["multiplying"], - &["multiply"], - &["multitasking"], - &["multitasking"], - &["multitude"], - &["multiverse"], - &["multiples"], - &["multiplayer"], - &["multiplying"], ], - range: 4..=12, + range: 3..=10, }; static WORD_MUK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36732,9 +71154,12 @@ static WORD_MUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_MUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sums")], - values: &[&["museums"]], - range: 4..=4, + 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 { @@ -36746,8 +71171,10 @@ pub static WORD_MUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("er"), dictgen::InsensitiveStr::Ascii("ering"), + dictgen::InsensitiveStr::Ascii("ule"), + dictgen::InsensitiveStr::Ascii("ules"), ], - values: &[&["murder"], &["murdering"]], + values: &[&["murder"], &["murdering"], &["module"], &["modules"]], range: 2..=5, }; @@ -36766,15 +71193,32 @@ pub static WORD_MUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("ytical")], - values: &[&["mystical"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("sing"), + dictgen::InsensitiveStr::Ascii("ytical"), + ], + values: &[&["missing"], &["mystical"]], + range: 4..=6, }; static WORD_MR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36794,14 +71238,14 @@ static WORD_MO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + 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, - None, - None, + Some(&WORD_MOH_NODE), Some(&WORD_MOI_NODE), None, None, @@ -36829,22 +71273,26 @@ static WORD_MOZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MOZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"], &["mozzarella"], &["mozzarella"], &["mozzarella"], + &["mozilla"], &["mozzarella"], ], - range: 5..=7, + range: 3..=7, }; static WORD_MOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36854,20 +71302,54 @@ static WORD_MOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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..=7, + range: 2..=8, }; static WORD_MOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36877,32 +71359,54 @@ static WORD_MOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("dle"), + dictgen::InsensitiveStr::Ascii("dule"), dictgen::InsensitiveStr::Ascii("nment"), dictgen::InsensitiveStr::Ascii("nring"), dictgen::InsensitiveStr::Ascii("ntan"), dictgen::InsensitiveStr::Ascii("nth"), 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"), ], values: &[ + &["module"], + &["module"], &["monument"], &["mourning"], &["mountain"], - &["month"], + &["month", "mouth"], &["mountain"], + &["mountpoint"], + &["mountpoints"], + &["mousepointer"], &["moustache"], &["moustache"], &["moisturizing"], &["mouthpiece"], &["mouthpiece"], &["mouthpiece"], + &["mount"], + &["mounted"], + &["mounting"], + &["mountpoint"], + &["mountpoints"], + &["mounts"], ], - range: 3..=9, + range: 2..=9, }; static WORD_MOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36912,7 +71416,12 @@ static WORD_MOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ation"), 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"), @@ -36925,6 +71434,7 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -36935,7 +71445,9 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -36950,7 +71462,12 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ovational"), ], values: &[ + &["notation", "rotation", "motivation"], &["motherboard"], + &["motor"], + &["motored"], + &["motoring"], + &["motors"], &["motherboards"], &["motherboard"], &["motherboards"], @@ -36963,6 +71480,7 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["motherboard"], &["motherboards"], &["motherboards"], + &["nothing"], &["motherboards"], &["motivational"], &["motivations"], @@ -36973,7 +71491,9 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["motivational"], &["motivate"], &["motivated"], + &["motivation"], &["montage"], + &["monotonic"], &["motorola"], &["motorcycle"], &["motorcycles"], @@ -36987,7 +71507,7 @@ pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["motorola"], &["motivational"], ], - range: 4..=10, + range: 3..=10, }; static WORD_MOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -36997,8 +71517,10 @@ static WORD_MOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -37008,11 +71530,15 @@ pub static WORD_MOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("quiters"), dictgen::InsensitiveStr::Ascii("quitto"), dictgen::InsensitiveStr::Ascii("qutio"), + dictgen::InsensitiveStr::Ascii("tlky"), dictgen::InsensitiveStr::Ascii("ture"), + dictgen::InsensitiveStr::Ascii("ty"), ], values: &[ + &["more", "mouse"], &["moisturizer"], &["moisturizing"], + &["mostly"], &["monster"], &["monsters"], &["monstrosity"], @@ -37022,14 +71548,16 @@ pub static WORD_MOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["mosquitoes"], &["mosquito"], &["mosquito"], + &["mostly"], &["moisture"], + &["mostly"], ], - range: 4..=9, + range: 1..=9, }; static WORD_MOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_MOR_CHILDREN), - value: None, + value: Some(&["more"]), }; pub static WORD_MOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -37038,8 +71566,10 @@ pub static WORD_MOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("gage"), dictgen::InsensitiveStr::Ascii("gatges"), @@ -37047,6 +71577,12 @@ pub static WORD_MOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -37075,15 +71611,23 @@ pub static WORD_MOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["morbidly"], &["morbidly"], &["morbidly"], + &["modern"], &["morbidly"], &["more"], &["moreover"], + &["moreover"], &["mortgage"], &["mortgages"], &["mortgages"], &["morphine"], &["morbidly"], &["morissette"], + &["normalise"], + &["normalised"], + &["normalises"], + &["normalize"], + &["normalized"], + &["normalizes"], &["mormons"], &["mormonism"], &["mormonism"], @@ -37116,9 +71660,13 @@ static WORD_MOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_MOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rhine")], - values: &[&["morphine"]], - range: 5..=5, + 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 { @@ -37127,9 +71675,13 @@ static WORD_MOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_MOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("nligt")], - values: &[&["moonlight"]], - range: 5..=5, + 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 { @@ -37148,7 +71700,7 @@ static WORD_MON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_MONI_NODE), None, - None, + Some(&WORD_MONK_NODE), None, None, None, @@ -37220,6 +71772,7 @@ pub static WORD_MONT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("eral"), dictgen::InsensitiveStr::Ascii("ioring"), dictgen::InsensitiveStr::Ascii("iors"), + dictgen::InsensitiveStr::Ascii("ly"), dictgen::InsensitiveStr::Ascii("nana"), dictgen::InsensitiveStr::Ascii("rel"), dictgen::InsensitiveStr::Ascii("s"), @@ -37240,6 +71793,7 @@ pub static WORD_MONT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["montreal"], &["monitoring"], &["monitors"], + &["monthly"], &["montana"], &["montreal"], &["months"], @@ -37266,6 +71820,7 @@ pub static WORD_MONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("tros"), dictgen::InsensitiveStr::Ascii("trosoty"), dictgen::InsensitiveStr::Ascii("trostiy"), + dictgen::InsensitiveStr::Ascii("trum"), dictgen::InsensitiveStr::Ascii("truos"), ], values: &[ @@ -37280,6 +71835,7 @@ pub static WORD_MONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["monstrous"], &["monstrosity"], &["monstrosity"], + &["monster"], &["monstrous"], ], range: 3..=7, @@ -37303,6 +71859,9 @@ static WORD_MONO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -37319,6 +71878,8 @@ pub static WORD_MONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("lothic"), dictgen::InsensitiveStr::Ascii("louge"), dictgen::InsensitiveStr::Ascii("lythic"), + dictgen::InsensitiveStr::Ascii("ntonicity"), + dictgen::InsensitiveStr::Ascii("pace"), dictgen::InsensitiveStr::Ascii("pilies"), dictgen::InsensitiveStr::Ascii("ploies"), dictgen::InsensitiveStr::Ascii("ploy"), @@ -37331,8 +71892,15 @@ pub static WORD_MONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -37349,6 +71917,8 @@ pub static WORD_MONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["monolithic"], &["monologue"], &["monolithic"], + &["monotonicity"], + &["monospace"], &["monopolies"], &["monopolies"], &["monopoly"], @@ -37361,8 +71931,23 @@ pub static WORD_MONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["monopoly"], &["monopolies"], &["monolithic"], + &["monitor"], + &["monitored"], + &["monitoring"], + &["monitors"], ], - range: 4..=8, + range: 3..=9, +}; + +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 { @@ -37372,7 +71957,10 @@ static WORD_MONI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -37380,6 +71968,9 @@ pub static WORD_MONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("tos"), ], values: &[ + &["monetary"], + &["monitor"], + &["monitoring"], &["monitoring"], &["monitored"], &["monitored"], @@ -37407,17 +71998,23 @@ pub static WORD_MONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic static WORD_MONE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_MONE_CHILDREN), - value: None, + 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"], &["monetize"]], - range: 5..=7, + values: &[ + &["monasteries"], + &["monastery", "monetary"], + &["monastic"], + &["monetize"], + ], + range: 4..=7, }; static WORD_MONA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -37443,7 +72040,12 @@ static WORD_MOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -37453,10 +72055,22 @@ pub static WORD_MOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], values: &[ + &["moment"], &["momentarily"], + &["moments"], + &["momentarily"], + &["momentary"], + &["moment"], &["momentarily"], &["momentarily"], &["momentarily"], @@ -37466,9 +72080,16 @@ pub static WORD_MOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["memento"], &["moments"], &["moments"], + &["memory"], &["moment"], + &["moment"], + &["moment"], + &["momentarily"], + &["memento", "moment"], + &["mementos", "moments"], + &["moments"], ], - range: 4..=9, + range: 3..=10, }; static WORD_MOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -37521,6 +72142,7 @@ static WORD_MOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("nt"), dictgen::InsensitiveStr::Ascii("sterizer"), dictgen::InsensitiveStr::Ascii("sterizing"), dictgen::InsensitiveStr::Ascii("storizing"), @@ -37533,6 +72155,7 @@ pub static WORD_MOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("sutrizing"), ], values: &[ + &["mount"], &["moisturizer"], &["moisturizing"], &["moisturizing"], @@ -37544,7 +72167,41 @@ pub static WORD_MOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["moisturizer"], &["moisturizing"], ], - range: 7..=9, + 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("ammedans")], + values: &[&["muslims"]], + range: 8..=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 { @@ -37563,40 +72220,360 @@ pub static WORD_MOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_MOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MOD_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_MOD_CHILDREN), value: None, }; -pub static WORD_MOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("eracion"), - dictgen::InsensitiveStr::Ascii("eratedly"), - dictgen::InsensitiveStr::Ascii("eraters"), - dictgen::InsensitiveStr::Ascii("erateurs"), - dictgen::InsensitiveStr::Ascii("eratey"), - dictgen::InsensitiveStr::Ascii("eratin"), - dictgen::InsensitiveStr::Ascii("eratley"), - dictgen::InsensitiveStr::Ascii("eratore"), - dictgen::InsensitiveStr::Ascii("eratorin"), - dictgen::InsensitiveStr::Ascii("eratorn"), - dictgen::InsensitiveStr::Ascii("erats"), - dictgen::InsensitiveStr::Ascii("erm"), - dictgen::InsensitiveStr::Ascii("ificacion"), - dictgen::InsensitiveStr::Ascii("ificaiton"), - dictgen::InsensitiveStr::Ascii("ificaitons"), - dictgen::InsensitiveStr::Ascii("ificato"), - dictgen::InsensitiveStr::Ascii("ificaton"), - dictgen::InsensitiveStr::Ascii("ificatons"), - dictgen::InsensitiveStr::Ascii("ifieras"), - dictgen::InsensitiveStr::Ascii("ifieres"), - dictgen::InsensitiveStr::Ascii("ifikation"), - dictgen::InsensitiveStr::Ascii("ifires"), - dictgen::InsensitiveStr::Ascii("ivational"), - dictgen::InsensitiveStr::Ascii("le"), - dictgen::InsensitiveStr::Ascii("ualr"), - dictgen::InsensitiveStr::Ascii("ulair"), + 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("lie"), + dictgen::InsensitiveStr::Ascii("lu"), + dictgen::InsensitiveStr::Ascii("lues"), ], values: &[ + &["modular"], + &["module"], + &["module"], + &["modules"], + &["module"], + &["modules"], + &["module"], + &["modular"], + &["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("ue"), + ], + values: &[&["model"], &["module"]], + range: 1..=2, +}; + +static WORD_MODI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_MODI_CHILDREN), + value: None, +}; + +pub static WORD_MODI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("cations"), + dictgen::InsensitiveStr::Ascii("fable"), + dictgen::InsensitiveStr::Ascii("faction"), + dictgen::InsensitiveStr::Ascii("factions"), + dictgen::InsensitiveStr::Ascii("fation"), + dictgen::InsensitiveStr::Ascii("fations"), + dictgen::InsensitiveStr::Ascii("fcation"), + dictgen::InsensitiveStr::Ascii("fcations"), + dictgen::InsensitiveStr::Ascii("fciation"), + dictgen::InsensitiveStr::Ascii("fciations"), + dictgen::InsensitiveStr::Ascii("fcication"), + dictgen::InsensitiveStr::Ascii("fcications"), + dictgen::InsensitiveStr::Ascii("fdied"), + dictgen::InsensitiveStr::Ascii("fdy"), + dictgen::InsensitiveStr::Ascii("fed"), + dictgen::InsensitiveStr::Ascii("fer"), + dictgen::InsensitiveStr::Ascii("fers"), + dictgen::InsensitiveStr::Ascii("fes"), + dictgen::InsensitiveStr::Ascii("ffer"), + dictgen::InsensitiveStr::Ascii("ffers"), + dictgen::InsensitiveStr::Ascii("fiation"), + dictgen::InsensitiveStr::Ascii("fiations"), + dictgen::InsensitiveStr::Ascii("ficacion"), + dictgen::InsensitiveStr::Ascii("ficaiton"), + dictgen::InsensitiveStr::Ascii("ficaitons"), + dictgen::InsensitiveStr::Ascii("ficatioon"), + dictgen::InsensitiveStr::Ascii("ficato"), + dictgen::InsensitiveStr::Ascii("ficaton"), + dictgen::InsensitiveStr::Ascii("ficatons"), + dictgen::InsensitiveStr::Ascii("fid"), + dictgen::InsensitiveStr::Ascii("fieras"), + dictgen::InsensitiveStr::Ascii("fieres"), + dictgen::InsensitiveStr::Ascii("fified"), + dictgen::InsensitiveStr::Ascii("fify"), + dictgen::InsensitiveStr::Ascii("fikation"), + dictgen::InsensitiveStr::Ascii("fing"), + dictgen::InsensitiveStr::Ascii("fires"), + dictgen::InsensitiveStr::Ascii("fiy"), + dictgen::InsensitiveStr::Ascii("fiyng"), + dictgen::InsensitiveStr::Ascii("fled"), + dictgen::InsensitiveStr::Ascii("fler"), + dictgen::InsensitiveStr::Ascii("flers"), + dictgen::InsensitiveStr::Ascii("ft"), + dictgen::InsensitiveStr::Ascii("fty"), + dictgen::InsensitiveStr::Ascii("fu"), + dictgen::InsensitiveStr::Ascii("fuable"), + dictgen::InsensitiveStr::Ascii("fued"), + dictgen::InsensitiveStr::Ascii("fx"), + dictgen::InsensitiveStr::Ascii("fyable"), + dictgen::InsensitiveStr::Ascii("ration"), + dictgen::InsensitiveStr::Ascii("vational"), + ], + values: &[ + &["modifications"], + &["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"], + &["modification"], + &["modification"], + &["modifications"], + &["modified"], + &["modifiers"], + &["modifiers"], + &["modified"], + &["modify"], + &["modification"], + &["modifying"], + &["modifiers"], + &["modify"], + &["modifying"], + &["modified"], + &["modifier"], + &["modifiers"], + &["modify"], + &["modify"], + &["modify"], + &["modifiable"], + &["modified"], + &["modify"], + &["modifiable"], + &["moderation"], + &["motivational"], + ], + range: 2..=10, +}; + +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("ll"), + 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: &[ + &["model"], &["moderation"], &["moderately"], &["moderates"], @@ -37609,33 +72586,74 @@ pub static WORD_MOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["moderation"], &["moderates"], &["modem"], - &["modification"], - &["modification"], - &["modifications"], - &["modification"], - &["modification"], - &["modifications"], - &["modifiers"], - &["modifiers"], - &["modification"], - &["modifiers"], - &["motivational"], - &["model"], - &["modular"], - &["modular"], + &["modernization"], + &["modernizations"], + &["modernizations"], + &["modernizations"], + &["modesetting"], + &["module"], + &["modules"], ], range: 2..=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("els"), + ], + values: &[&["model"], &["models"]], + range: 2..=3, +}; + 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("rotransactions")], - values: &[&["microtransactions"]], - range: 14..=14, + 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 { @@ -37645,12 +72663,51 @@ static WORD_MOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["mobility"], &["mobility"], &["mobility"]], - range: 4..=6, + 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")], + values: &[&["many"]], + range: 2..=2, +}; + +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 { @@ -37663,10 +72720,22 @@ pub static WORD_MK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"]], - range: 2..=4, + 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 { @@ -37675,7 +72744,7 @@ static WORD_MI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_MIA_NODE), None, Some(&WORD_MIC_NODE), Some(&WORD_MID_NODE), @@ -37683,14 +72752,14 @@ static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_MIG_NODE), None, + Some(&WORD_MII_NODE), None, - None, - None, + Some(&WORD_MIK_NODE), Some(&WORD_MIL_NODE), Some(&WORD_MIM_NODE), Some(&WORD_MIN_NODE), None, - None, + Some(&WORD_MIP_NODE), None, Some(&WORD_MIR_NODE), Some(&WORD_MIS_NODE), @@ -37698,20 +72767,38 @@ static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, 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("igaiton")], - values: &[&["mitigation"]], - range: 7..=7, + keys: &[ + dictgen::InsensitiveStr::Ascii("igaiton"), + dictgen::InsensitiveStr::Ascii("tigate"), + ], + values: &[&["mitigation"], &["mitigate"]], + range: 6..=7, }; static WORD_MIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -37721,7 +72808,7 @@ static WORD_MIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_MISA_NODE), - None, + Some(&WORD_MISB_NODE), Some(&WORD_MISC_NODE), Some(&WORD_MISD_NODE), Some(&WORD_MISE_NODE), @@ -37732,7 +72819,7 @@ static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, - None, + Some(&WORD_MISM_NODE), Some(&WORD_MISN_NODE), Some(&WORD_MISO_NODE), Some(&WORD_MISP_NODE), @@ -37856,10 +72943,16 @@ pub static WORD_MIST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("erious"), dictgen::InsensitiveStr::Ascii("eriously"), dictgen::InsensitiveStr::Ascii("ery"), dictgen::InsensitiveStr::Ascii("eryous"), + dictgen::InsensitiveStr::Ascii("matches"), dictgen::InsensitiveStr::Ascii("read"), dictgen::InsensitiveStr::Ascii("readed"), ], @@ -37870,10 +72963,16 @@ pub static WORD_MIST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["mistakenly"], &["mistakenly"], &["mistakenly"], + &["mismatch"], + &["mismatched"], + &["mismatched"], + &["mismatches"], + &["mismatching"], &["mysterious"], &["mysteriously"], &["mystery"], &["mysterious"], + &["mismatches"], &["mistreated"], &["mistreated"], ], @@ -37887,9 +72986,18 @@ static WORD_MISS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_MISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("ings"), dictgen::InsensitiveStr::Ascii("ionaire"), dictgen::InsensitiveStr::Ascii("ionaires"), dictgen::InsensitiveStr::Ascii("ionairy"), @@ -37907,23 +73015,47 @@ pub static WORD_MISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("issipppi"), dictgen::InsensitiveStr::Ascii("issppi"), dictgen::InsensitiveStr::Ascii("le"), + dictgen::InsensitiveStr::Ascii("leading"), 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("pelt"), + 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"), ], values: &[ + &["misconfiguration"], + &["misconfigure"], + &["misconfigured"], + &["misconfigures"], + &["misconfiguring"], + &["miscounted"], &["mizzen"], + &["missing"], &["mission"], &["missiles"], + &["mission", "missing"], + &["missing"], &["missionaries"], &["missionaries"], &["missionary"], @@ -37941,20 +73073,35 @@ pub static WORD_MISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["mississippi"], &["mississippi"], &["missile"], + &["misleading"], &["missiles"], + &["mismanaged"], + &["mismatch"], + &["mismatched"], + &["mismatched"], + &["mismatches"], + &["mismatching"], &["missionary"], &["missouri"], &["missouri"], &["misspelling"], + &["misspell"], &["misspelled"], &["misspelling"], &["misspelled"], &["misspelled"], &["misspelling"], &["misspelling"], - &["misspelled"], + &["missing"], + &["mistake"], + &["mistaken"], + &["mistakes"], + &["mistype"], + &["mistypes"], + &["misunderstood"], + &["misuse"], ], - range: 2..=8, + range: 2..=13, }; static WORD_MISR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -38004,15 +73151,19 @@ pub static WORD_MISP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ell"), dictgen::InsensitiveStr::Ascii("elled"), dictgen::InsensitiveStr::Ascii("elling"), + dictgen::InsensitiveStr::Ascii("elt"), + dictgen::InsensitiveStr::Ascii("ronounciation"), dictgen::InsensitiveStr::Ascii("roportionate"), ], values: &[ &["misspell"], &["misspelled"], &["misspelling"], + &["misspelt"], + &["mispronunciation"], &["disproportionate"], ], - range: 3..=12, + range: 3..=13, }; static WORD_MISO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -38093,6 +73244,33 @@ pub static WORD_MISN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -38103,6 +73281,9 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -38119,6 +73300,7 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -38129,6 +73311,7 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -38137,6 +73320,9 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["missile"], &["misinformed"], &["misinformed"], + &["missing"], + &["misinterpret"], + &["misinterpreted"], &["misinterpret"], &["misinterpret"], &["misinterpret"], @@ -38153,6 +73339,7 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["misinterpreting"], &["misinterpreting"], &["misinterpreting"], + &["misinterpret"], &["misinterpreted"], &["misinterpreting"], &["misinterpreting"], @@ -38163,6 +73350,7 @@ pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["misinterpret"], &["misinterpreted"], &["misinterpreting"], + &["missing"], &["mission"], &["missionaries"], &["missionary"], @@ -38191,12 +73379,18 @@ static WORD_MISF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["misfortune"], &["misfortune"], &["misfortunes"]], - range: 6..=8, + values: &[ + &["malformed"], + &["misfortune"], + &["misfortune"], + &["misfortunes"], + ], + range: 5..=8, }; static WORD_MISE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -38268,9 +73462,11 @@ pub static WORD_MISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("hievious"), @@ -38282,7 +73478,9 @@ pub static WORD_MISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: &[ @@ -38297,6 +73495,8 @@ pub static WORD_MISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["miscellaneous"], &["miscellaneous"], &["miscellaneous"], + &["miscellaneous"], + &["miscellaneous"], &["mischievous"], &["mischievous"], &["mischievous"], @@ -38308,12 +73508,25 @@ pub static WORD_MISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["miscommunication"], &["misconceptions"], &["misconceptions"], + &["misconfigured"], &["misconceptions"], + &["microsoft"], &["miscommunication"], ], range: 6..=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, @@ -38321,11 +73534,19 @@ static WORD_MISA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_MISA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("lignement"), + dictgen::InsensitiveStr::Ascii("linged"), dictgen::InsensitiveStr::Ascii("nderstood"), dictgen::InsensitiveStr::Ascii("ndrony"), dictgen::InsensitiveStr::Ascii("ndy"), ], - values: &[&["misunderstood"], &["misandry"], &["misandry"]], + values: &[ + &["misalignment"], + &["misaligned"], + &["misunderstood"], + &["misandry"], + &["misandry"], + ], range: 3..=9, }; @@ -38350,17 +73571,33 @@ pub static WORD_MIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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("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: &[ @@ -38378,157 +73615,397 @@ pub static WORD_MIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["miracles"], &["microatx"], &["microcenter"], + &["micronesia"], &["microphone"], &["microphones"], &["microscope"], + &["microscopes"], &["microscopic"], + &["microsoft"], &["microtransactions"], &["microtransactions"], &["microwave"], &["microwaves"], &["migraine"], + &["migrate"], + &["migrated"], + &["migrates"], + &["mirror", "minor"], + &["mirrored"], + &["mirroring"], + &["mirror"], + &["mirrored"], + &["mirroring"], + &["mirrors"], + &["mirrors", "minors"], + &["mirror"], &["mirrored"], &["mirrored"], + &["mirror"], &["mirrored"], ], - range: 4..=14, + range: 2..=14, }; -static WORD_MIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MIN_CHILDREN), +static WORD_MIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_MIP_CHILDREN), value: None, }; -pub static WORD_MIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("amilist"), - dictgen::InsensitiveStr::Ascii("ature"), - dictgen::InsensitiveStr::Ascii("dcarck"), - dictgen::InsensitiveStr::Ascii("dcrak"), - dictgen::InsensitiveStr::Ascii("dleslly"), - dictgen::InsensitiveStr::Ascii("dlessely"), - dictgen::InsensitiveStr::Ascii("dlessley"), - dictgen::InsensitiveStr::Ascii("dlessy"), - dictgen::InsensitiveStr::Ascii("erales"), - dictgen::InsensitiveStr::Ascii("eras"), - dictgen::InsensitiveStr::Ascii("erial"), - dictgen::InsensitiveStr::Ascii("giame"), - dictgen::InsensitiveStr::Ascii("image"), - dictgen::InsensitiveStr::Ascii("imalisitc"), - dictgen::InsensitiveStr::Ascii("imalisity"), - dictgen::InsensitiveStr::Ascii("imals"), - dictgen::InsensitiveStr::Ascii("imalstic"), - dictgen::InsensitiveStr::Ascii("imalt"), - dictgen::InsensitiveStr::Ascii("imazing"), - dictgen::InsensitiveStr::Ascii("imilast"), - dictgen::InsensitiveStr::Ascii("imilist"), - dictgen::InsensitiveStr::Ascii("imini"), - dictgen::InsensitiveStr::Ascii("imium"), - dictgen::InsensitiveStr::Ascii("inalist"), - dictgen::InsensitiveStr::Ascii("inos"), - dictgen::InsensitiveStr::Ascii("interpret"), - dictgen::InsensitiveStr::Ascii("interpreting"), - dictgen::InsensitiveStr::Ascii("ipulating"), - dictgen::InsensitiveStr::Ascii("ipulation"), - dictgen::InsensitiveStr::Ascii("ipulative"), - dictgen::InsensitiveStr::Ascii("isclue"), - dictgen::InsensitiveStr::Ascii("iscue"), - dictgen::InsensitiveStr::Ascii("iscuel"), - dictgen::InsensitiveStr::Ascii("isterens"), - dictgen::InsensitiveStr::Ascii("isteres"), - dictgen::InsensitiveStr::Ascii("isterios"), - dictgen::InsensitiveStr::Ascii("isterns"), - dictgen::InsensitiveStr::Ascii("istery"), - dictgen::InsensitiveStr::Ascii("istr"), - dictgen::InsensitiveStr::Ascii("isty"), - dictgen::InsensitiveStr::Ascii("isucle"), - dictgen::InsensitiveStr::Ascii("itaure"), - dictgen::InsensitiveStr::Ascii("ituare"), - dictgen::InsensitiveStr::Ascii("neaoplis"), - dictgen::InsensitiveStr::Ascii("neaplis"), - dictgen::InsensitiveStr::Ascii("neaplois"), - dictgen::InsensitiveStr::Ascii("neapolites"), - dictgen::InsensitiveStr::Ascii("neapols"), - dictgen::InsensitiveStr::Ascii("neosta"), - dictgen::InsensitiveStr::Ascii("nesotta"), - dictgen::InsensitiveStr::Ascii("nestoa"), - dictgen::InsensitiveStr::Ascii("niapolis"), - dictgen::InsensitiveStr::Ascii("oins"), - dictgen::InsensitiveStr::Ascii("oritets"), - dictgen::InsensitiveStr::Ascii("oroties"), - dictgen::InsensitiveStr::Ascii("sicule"), - dictgen::InsensitiveStr::Ascii("siter"), - dictgen::InsensitiveStr::Ascii("siters"), - dictgen::InsensitiveStr::Ascii("sitry"), - dictgen::InsensitiveStr::Ascii("stries"), - dictgen::InsensitiveStr::Ascii("stry"), - dictgen::InsensitiveStr::Ascii("umum"), + dictgen::InsensitiveStr::Ascii("m"), + dictgen::InsensitiveStr::Ascii("mum"), + dictgen::InsensitiveStr::Ascii("scle"), + dictgen::InsensitiveStr::Ascii("sculy"), + dictgen::InsensitiveStr::Ascii("ts"), ], values: &[ - &["minimalist"], - &["miniature"], - &["mindcrack"], - &["mindcrack"], - &["mindlessly"], - &["mindlessly"], - &["mindlessly"], - &["mindlessly"], - &["minerals"], - &["minerals"], - &["mineral"], - &["minigame"], - &["minigame"], - &["minimalist"], - &["minimalist"], - &["minimalist"], - &["minimalist"], - &["minimalist"], - &["minimizing"], - &["minimalist"], - &["minimalist"], - &["minimizing"], &["minimum"], - &["minimalist"], - &["minions"], - &["misinterpret"], - &["misinterpreting"], - &["manipulating"], - &["manipulation"], - &["manipulative"], - &["miniscule"], - &["miniscule"], - &["miniscule"], - &["ministers"], - &["ministers"], - &["ministers"], - &["ministers"], - &["ministry"], - &["minister"], - &["ministry"], - &["miniscule"], - &["miniature"], - &["miniature"], - &["minneapolis"], - &["minneapolis"], - &["minneapolis"], - &["minneapolis"], - &["minneapolis"], - &["minnesota"], - &["minnesota"], - &["minnesota"], - &["minneapolis"], - &["minions"], - &["minorities"], - &["minorities"], + &["minimum"], + &["minuscule"], + &["minusculely", "minuscule"], + &["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"], + &["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("ritets"), + dictgen::InsensitiveStr::Ascii("roties"), + ], + values: &[&["minions"], &["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"), + ], + values: &[ + &["minneapolis"], + &["minneapolis"], + &["minneapolis"], + &["minneapolis"], + &["minneapolis"], + &["minnesota"], + &["minnesota"], + &["minnesota"], + &["minneapolis"], + ], + range: 5..=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("um"), + ], + values: &[&["minimal"], &["minimum"]], + range: 2..=2, +}; + +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("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("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: &[ + &["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"], + &["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: 4..=12, + 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 { @@ -38538,88 +74015,181 @@ static WORD_MIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), ], - values: &[&["minimum"], &["minimalist"]], - range: 4..=7, + values: &[ + &["mismatch"], + &["mismatched"], + &["mismatched"], + &["mismatches"], + &["mismatching"], + &["mismatch"], + &["mismatched"], + &["mismatched"], + &["mismatches"], + &["mismatching"], + &["mimicking"], + &["mimic"], + &["mimics"], + &["minimal"], + &["minimise", "minimise"], + &["minimize", "minimize"], + &["minimum"], + &["minimum"], + &["minimal"], + &["minimalist"], + &["minimally"], + &["minimally"], + ], + range: 3..=7, }; static WORD_MIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MIL_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_MIL_CHILDREN), value: None, }; -pub static WORD_MIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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, + None, + None, +]; + +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("awukee"), - dictgen::InsensitiveStr::Ascii("eau"), - dictgen::InsensitiveStr::Ascii("ennia"), - dictgen::InsensitiveStr::Ascii("ennium"), - dictgen::InsensitiveStr::Ascii("estons"), - dictgen::InsensitiveStr::Ascii("etsones"), - dictgen::InsensitiveStr::Ascii("eu"), - dictgen::InsensitiveStr::Ascii("igram"), - dictgen::InsensitiveStr::Ascii("iitas"), - dictgen::InsensitiveStr::Ascii("ion"), - dictgen::InsensitiveStr::Ascii("iraty"), - dictgen::InsensitiveStr::Ascii("isecond"), - dictgen::InsensitiveStr::Ascii("itais"), - dictgen::InsensitiveStr::Ascii("itat"), - dictgen::InsensitiveStr::Ascii("itiades"), - dictgen::InsensitiveStr::Ascii("itians"), - dictgen::InsensitiveStr::Ascii("itiants"), - dictgen::InsensitiveStr::Ascii("itis"), - dictgen::InsensitiveStr::Ascii("lenia"), - dictgen::InsensitiveStr::Ascii("lenial"), - dictgen::InsensitiveStr::Ascii("lenialism"), - dictgen::InsensitiveStr::Ascii("lenian"), - dictgen::InsensitiveStr::Ascii("lenium"), - dictgen::InsensitiveStr::Ascii("lenna"), - dictgen::InsensitiveStr::Ascii("lienaire"), - dictgen::InsensitiveStr::Ascii("linnium"), - dictgen::InsensitiveStr::Ascii("lionairre"), - dictgen::InsensitiveStr::Ascii("lionairres"), - dictgen::InsensitiveStr::Ascii("lionairs"), - dictgen::InsensitiveStr::Ascii("lionar"), - dictgen::InsensitiveStr::Ascii("lionarie"), - dictgen::InsensitiveStr::Ascii("lionaries"), - dictgen::InsensitiveStr::Ascii("lioniare"), - dictgen::InsensitiveStr::Ascii("lioniares"), - dictgen::InsensitiveStr::Ascii("litary"), - dictgen::InsensitiveStr::Ascii("lon"), - dictgen::InsensitiveStr::Ascii("tary"), - dictgen::InsensitiveStr::Ascii("tiant"), - dictgen::InsensitiveStr::Ascii("uwakee"), - dictgen::InsensitiveStr::Ascii("wakuee"), - dictgen::InsensitiveStr::Ascii("wuakee"), + 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("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: &[ - &["milwaukee"], - &["milieu"], - &["millennia"], &["millennium"], - &["milestones"], - &["milestones"], - &["milieu"], - &["milligram"], - &["militias"], - &["million"], - &["military"], - &["millisecond"], - &["militias"], - &["militant"], - &["militias"], - &["militias"], - &["militias"], - &["militias"], &["millennia"], &["millennial"], &["millennialism"], + &["millennials"], &["millennia"], &["millennium"], &["millennia"], &["millionaire"], + &["millisecond"], + &["milliseconds"], &["millennium"], &["millionaire"], &["millionaire"], @@ -38629,15 +74199,161 @@ pub static WORD_MIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["millionaires"], &["millionaire"], &["millionaires"], + &["millisecond"], + &["milliseconds"], + &["millisecond"], + &["milliseconds"], + &["militant"], &["military"], &["million"], - &["military"], - &["militant"], - &["milwaukee"], - &["milwaukee"], - &["milwaukee"], + &["millisecond"], + &["milliseconds"], + &["millisecond"], + &["milliseconds"], ], - range: 2..=10, + range: 2..=9, +}; + +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("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"], + &["milligram"], + &["militias"], + &["millimeter"], + &["millimeters"], + &["millimetre"], + &["millimetres"], + &["millimeters"], + &["million"], + &["military"], + &["millisecond"], + &["milliseconds"], + &["milliseconds"], + &["militias"], + &["militant"], + &["militias"], + &["militias"], + &["militias"], + &["militias"], + &["millivolts"], + ], + range: 2..=7, +}; + +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_MIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -38652,8 +74368,11 @@ pub static WORD_MIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: &[ &["mitigation"], @@ -38661,10 +74380,13 @@ pub static WORD_MIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["migraines"], &["migrants"], &["migrants"], + &["migratable"], &["migraine"], &["migraines"], + &["might", "midget"], + &["might"], ], - range: 4..=7, + range: 1..=8, }; static WORD_MID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -38689,6 +74411,7 @@ pub static WORD_MID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("twon"), @@ -38709,6 +74432,7 @@ pub static WORD_MID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["midfield"], &["midfielder"], &["midfielders"], + &["modified"], &["mindlessly"], &["midtown"], &["midtown"], @@ -38717,89 +74441,139 @@ pub static WORD_MID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_MIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MIC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_MIC_CHILDREN), value: None, }; -pub static WORD_MIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("hagan"), - dictgen::InsensitiveStr::Ascii("helline"), - dictgen::InsensitiveStr::Ascii("hellle"), - dictgen::InsensitiveStr::Ascii("hgian"), - dictgen::InsensitiveStr::Ascii("hina"), - dictgen::InsensitiveStr::Ascii("orcenter"), - dictgen::InsensitiveStr::Ascii("orphones"), - dictgen::InsensitiveStr::Ascii("ortransactions"), - dictgen::InsensitiveStr::Ascii("orwave"), - dictgen::InsensitiveStr::Ascii("orwaves"), - dictgen::InsensitiveStr::Ascii("oscopy"), - dictgen::InsensitiveStr::Ascii("rocender"), - dictgen::InsensitiveStr::Ascii("rocentre"), - dictgen::InsensitiveStr::Ascii("rocentres"), - dictgen::InsensitiveStr::Ascii("rocentro"), - dictgen::InsensitiveStr::Ascii("rohpone"), - dictgen::InsensitiveStr::Ascii("rohpones"), - dictgen::InsensitiveStr::Ascii("rophen"), - dictgen::InsensitiveStr::Ascii("rophonies"), - dictgen::InsensitiveStr::Ascii("roscoop"), - dictgen::InsensitiveStr::Ascii("roscophic"), - dictgen::InsensitiveStr::Ascii("roscopice"), - dictgen::InsensitiveStr::Ascii("roscoptic"), - dictgen::InsensitiveStr::Ascii("roscrope"), - dictgen::InsensitiveStr::Ascii("rostansactions"), - dictgen::InsensitiveStr::Ascii("rotax"), - dictgen::InsensitiveStr::Ascii("rotramsactions"), - dictgen::InsensitiveStr::Ascii("rotranasctions"), - dictgen::InsensitiveStr::Ascii("rotransacations"), - dictgen::InsensitiveStr::Ascii("rotransacciones"), - dictgen::InsensitiveStr::Ascii("rotransacions"), - dictgen::InsensitiveStr::Ascii("rotransacitons"), - dictgen::InsensitiveStr::Ascii("rotransacrions"), - dictgen::InsensitiveStr::Ascii("rotransacting"), - dictgen::InsensitiveStr::Ascii("rotransactioms"), - dictgen::InsensitiveStr::Ascii("rotransactional"), - dictgen::InsensitiveStr::Ascii("rotransactioned"), - dictgen::InsensitiveStr::Ascii("rotransactios"), - dictgen::InsensitiveStr::Ascii("rotransactiosn"), - dictgen::InsensitiveStr::Ascii("rotransacton"), - dictgen::InsensitiveStr::Ascii("rotransactons"), - dictgen::InsensitiveStr::Ascii("rotransations"), - dictgen::InsensitiveStr::Ascii("rotranscation"), - dictgen::InsensitiveStr::Ascii("rotranscations"), - dictgen::InsensitiveStr::Ascii("rotrasnactions"), - dictgen::InsensitiveStr::Ascii("rovaves"), - dictgen::InsensitiveStr::Ascii("rovaxes"), - dictgen::InsensitiveStr::Ascii("rowae"), - dictgen::InsensitiveStr::Ascii("rowavees"), - dictgen::InsensitiveStr::Ascii("rowavers"), - dictgen::InsensitiveStr::Ascii("rpohone"), + 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("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("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: &[ - &["michigan"], - &["michelle"], - &["michelle"], - &["michigan"], - &["michigan"], + &["microcontroller"], + &["microcontrollers"], &["microcenter"], + &["microcenter"], + &["microcenter"], + &["microcenter"], + &["microcontroller"], + &["microcontrollers"], + &["microsoft"], + &["microphone"], &["microphones"], - &["microtransactions"], - &["microwave"], - &["microwaves"], - &["microscopy"], - &["microcenter"], - &["microcenter"], - &["microcenter"], - &["microcenter"], + &["microcontroller"], + &["microcontrollers"], &["microphone"], &["microphones"], &["microphone"], &["microphones"], + &["microprocessor"], + &["microprocessors"], &["microscope"], &["microscopic"], &["microscope"], &["microscopic"], &["microscope"], + &["microsecond"], + &["microseconds"], + &["microsoft"], + &["microchip"], + &["microchips"], + &["microsoft"], + &["microsoft"], &["microtransactions"], &["microatx"], &["microtransactions"], @@ -38827,8 +74601,100 @@ pub static WORD_MIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["microwaves"], &["microwaves"], &["microphones"], + &["microsoft"], + &["microsoft"], ], - range: 4..=15, + 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 { @@ -38849,13 +74715,13 @@ static WORD_ME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_MEA_NODE), - None, + Some(&WORD_MEB_NODE), Some(&WORD_MEC_NODE), Some(&WORD_MED_NODE), Some(&WORD_MEE_NODE), None, Some(&WORD_MEG_NODE), - None, + Some(&WORD_MEH_NODE), Some(&WORD_MEI_NODE), None, None, @@ -38872,10 +74738,21 @@ static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_MEX_NODE), - None, + Some(&WORD_MEY_NODE), None, ]; +static WORD_MEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_MEY_CHILDREN), + value: None, +}; + +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, @@ -38914,7 +74791,7 @@ static WORD_MET_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_META_NODE), None, None, - None, + Some(&WORD_METD_NODE), Some(&WORD_METE_NODE), None, None, @@ -39011,12 +74888,20 @@ static WORD_METO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_METO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("ds"), dictgen::InsensitiveStr::Ascii("phorical"), dictgen::InsensitiveStr::Ascii("phorically"), dictgen::InsensitiveStr::Ascii("rpolitan"), ], - values: &[&["metaphorical"], &["metaphorically"], &["metropolitan"]], - range: 8..=10, + values: &[ + &["method"], + &["methods"], + &["metaphorical"], + &["metaphorically"], + &["metropolitan"], + ], + range: 1..=10, }; static WORD_METL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39037,11 +74922,18 @@ static WORD_METI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_METI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("oned"), dictgen::InsensitiveStr::Ascii("phorical"), dictgen::InsensitiveStr::Ascii("phorically"), ], - values: &[&["metaphorical"], &["metaphorically"]], - range: 8..=10, + values: &[ + &["mention"], + &["mentioned"], + &["metaphorical"], + &["metaphorically"], + ], + range: 2..=10, }; static WORD_METH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39058,13 +74950,25 @@ pub static WORD_METH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("aporical"), dictgen::InsensitiveStr::Ascii("aporically"), dictgen::InsensitiveStr::Ascii("apors"), + dictgen::InsensitiveStr::Ascii("d"), + 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("os"), + dictgen::InsensitiveStr::Ascii("ot"), + dictgen::InsensitiveStr::Ascii("ots"), ], values: &[ &["mathematician"], @@ -39074,15 +74978,27 @@ pub static WORD_METH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["metaphorical"], &["metaphorically"], &["metaphors"], + &["method"], + &["methods"], &["mathematical"], &["mathematician"], + &["method"], + &["methods"], + &["method"], + &["method"], + &["method"], + &["methods"], &["methodology"], &["methodology"], &["methodology"], &["methodology"], + &["methods"], &["methodology"], + &["methods", "method"], + &["method"], + &["methods"], ], - range: 4..=10, + range: 1..=10, }; static WORD_METE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39095,6 +75011,8 @@ pub static WORD_METE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -39103,11 +75021,24 @@ pub static WORD_METE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["metaphorical"], &["metaphorically"], &["metaphysical"], + &["material"], + &["materials"], &["meteorologist"], &["meteorology"], &["heterosexual"], ], - range: 6..=10, + 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 { @@ -39127,6 +75058,8 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("bolitic"), dictgen::InsensitiveStr::Ascii("bolizm"), dictgen::InsensitiveStr::Ascii("bolsim"), + dictgen::InsensitiveStr::Ascii("charater"), + dictgen::InsensitiveStr::Ascii("charaters"), dictgen::InsensitiveStr::Ascii("gaem"), dictgen::InsensitiveStr::Ascii("gem"), dictgen::InsensitiveStr::Ascii("hpor"), @@ -39136,9 +75069,12 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -39155,6 +75091,8 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("physicals"), dictgen::InsensitiveStr::Ascii("physicans"), dictgen::InsensitiveStr::Ascii("physisch"), + dictgen::InsensitiveStr::Ascii("progamming"), + dictgen::InsensitiveStr::Ascii("tdata"), ], values: &[ &["metabolism"], @@ -39167,6 +75105,8 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["metabolic"], &["metabolism"], &["metabolism"], + &["metacharacter"], + &["metacharacters"], &["metagame"], &["metagame"], &["metaphor"], @@ -39176,9 +75116,12 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["metallurgy"], &["metagame"], &["metamorphosis"], + &["metapackage"], + &["metapackages"], &["metaphysical"], &["metaphysics"], &["metaphors"], + &["metaphor"], &["metaphors"], &["metaphorical"], &["metaphorically"], @@ -39195,6 +75138,8 @@ pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["metaphysics"], &["metaphysics"], &["metaphysics"], + &["metaprogramming"], + &["metadata"], ], range: 3..=10, }; @@ -39206,28 +75151,88 @@ static WORD_MES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("senging"), dictgen::InsensitiveStr::Ascii("sgaed"), + dictgen::InsensitiveStr::Ascii("sgaes"), + dictgen::InsensitiveStr::Ascii("sge"), + dictgen::InsensitiveStr::Ascii("sges"), dictgen::InsensitiveStr::Ascii("siach"), + 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"], + &["message"], &["messaged"], &["messages"], &["messaged"], &["messages"], + &["messagequeue"], + &["messaging"], + &["message"], + &["messages"], + &["messages"], &["messiah"], &["messenger"], + &["messengers"], + &["message"], &["messaging"], &["messaged"], + &["messages"], + &["message"], + &["messages"], &["messiah"], + &["message"], + &["messages"], + &["measure"], + &["measured"], + &["measurement"], + &["measures"], + &["measuring"], + &["measurement"], + &["measure"], + &["measured"], + &["measurement"], + &["measurements"], + &["measures"], + &["measuring"], + &["measurement"], ], - range: 4..=7, + range: 2..=10, }; static WORD_MER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39238,6 +75243,7 @@ static WORD_MER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("anda"), + dictgen::InsensitiveStr::Ascii("cahnt"), dictgen::InsensitiveStr::Ascii("canaries"), dictgen::InsensitiveStr::Ascii("caneries"), dictgen::InsensitiveStr::Ascii("canery"), @@ -39254,6 +75260,7 @@ pub static WORD_MER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -39263,13 +75270,23 @@ pub static WORD_MER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("curcy"), dictgen::InsensitiveStr::Ascii("curey"), 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: &[ - &["veranda"], + &["veranda", "miranda"], + &["merchant"], &["mercenaries"], &["mercenaries"], &["mercenary"], @@ -39286,6 +75303,7 @@ pub static WORD_MER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["merchandise"], &["merchants"], &["merchants"], + &["merchantability"], &["merchants"], &["merchant"], &["merchandise"], @@ -39295,12 +75313,21 @@ pub static WORD_MER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["mercury"], &["mercury"], &["merciful"], + &["mergeable"], + &["merge"], + &["merge"], + &["merged"], + &["merging"], &["merchant"], &["merchants"], &["merciful"], + &["merely"], + &["memory"], + &["memory"], + &["mirrors"], &["mercury"], ], - range: 4..=8, + range: 2..=12, }; static WORD_MEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39325,33 +75352,71 @@ static WORD_MEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ally"), + dictgen::InsensitiveStr::Ascii("as"), dictgen::InsensitiveStr::Ascii("caing"), + dictgen::InsensitiveStr::Ascii("etion"), + dictgen::InsensitiveStr::Ascii("etioned"), + dictgen::InsensitiveStr::Ascii("etioning"), + dictgen::InsensitiveStr::Ascii("etions"), + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("ioned"), + dictgen::InsensitiveStr::Ascii("ions"), 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"], &["menacing"], - &["menstrual"], - &["menstrual"], - &["menstrual"], - &["menstrual"], - &["mentally"], - &["mentally"], - &["mentions"], + &["mention"], + &["mentioned"], &["mentioning"], &["mentions"], + &["mention", "minion"], + &["mentioned"], + &["mentions", "minions"], + &["menstrual"], + &["menstrual"], + &["menstrual"], + &["menstrual"], + &["meant"], + &["mentally"], + &["mentally"], + &["methods"], + &["mentioned"], + &["mentioned"], + &["mentions"], &["mentioning"], + &["mentioned"], + &["mentions"], + &["mentioning"], + &["mentioned"], + &["manual"], + &["menu"], + &["menus"], + &["menuitems"], + &["menu", "many"], ], - range: 4..=8, + range: 1..=8, }; static WORD_MEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39361,30 +75426,84 @@ static WORD_MEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("mber"), + dictgen::InsensitiveStr::Ascii("mory"), 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("pry"), + dictgen::InsensitiveStr::Ascii("roy"), ], values: &[ + &["membrane"], &["membranophone"], &["membrane"], &["membrane"], + &["membranes"], + &["memcache"], + &["memcached"], + &["measurement"], + &["member"], + &["remembered"], + &["members"], + &["membership"], + &["memberships"], + &["member"], + &["memberof"], + &["members"], + &["member", "remember"], + &["members"], + &["memory"], + &["memento"], + &["memory"], &["member"], &["memorization"], + &["membership"], + &["memberships"], + &["memory"], + &["member"], + &["memory"], + &["memory"], + &["memory"], &["memory"], &["memory"], &["memorize"], &["memorization"], &["memorization"], + &["memory"], + &["memory"], ], - range: 4..=10, + range: 2..=10, }; static WORD_MEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39431,12 +75550,28 @@ static WORD_MEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("da"), dictgen::InsensitiveStr::Ascii("dcare"), dictgen::InsensitiveStr::Ascii("xcan"), dictgen::InsensitiveStr::Ascii("xcans"), ], - values: &[&["medicare"], &["mexican"], &["mexicans"]], - range: 4..=5, + values: &[&["media"], &["medicare"], &["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("ods"), + dictgen::InsensitiveStr::Ascii("tod"), + dictgen::InsensitiveStr::Ascii("tods"), + ], + values: &[&["methods"], &["method"], &["methods"]], + range: 3..=4, }; static WORD_MEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39446,11 +75581,13 @@ static WORD_MEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["megathread"], &["megatron"]], - range: 5..=6, + values: &[&["mechanism"], &["megathread"], &["megatron"], &["merge"]], + range: 1..=6, }; static WORD_MEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39459,9 +75596,14 @@ static WORD_MEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_MEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rkrat")], - values: &[&["meerkat"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ds"), + dictgen::InsensitiveStr::Ascii("ns"), + dictgen::InsensitiveStr::Ascii("rkrat"), + dictgen::InsensitiveStr::Ascii("tign"), + ], + values: &[&["needs"], &["means"], &["meerkat"], &["meeting"]], + range: 2..=5, }; static WORD_MED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39472,10 +75614,13 @@ static WORD_MED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("acine"), + dictgen::InsensitiveStr::Ascii("ai"), dictgen::InsensitiveStr::Ascii("atite"), dictgen::InsensitiveStr::Ascii("eival"), dictgen::InsensitiveStr::Ascii("eterranean"), dictgen::InsensitiveStr::Ascii("evial"), + dictgen::InsensitiveStr::Ascii("hod"), + dictgen::InsensitiveStr::Ascii("hods"), dictgen::InsensitiveStr::Ascii("iaction"), dictgen::InsensitiveStr::Ascii("iavel"), dictgen::InsensitiveStr::Ascii("icacion"), @@ -39528,10 +75673,13 @@ pub static WORD_MED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["medicine"], + &["media"], &["meditate"], &["medieval"], &["mediterranean"], &["medieval"], + &["method"], + &["methods"], &["medications"], &["medieval"], &["medication"], @@ -39547,7 +75695,7 @@ pub static WORD_MED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["medicine"], &["medicines"], &["medicines"], - &["mediciny"], + &["mediciny", "medicine", "medicinal"], &["medicines"], &["medicine"], &["mediocre"], @@ -39582,7 +75730,7 @@ pub static WORD_MED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["medieval"], &["mediocre"], ], - range: 4..=11, + range: 2..=11, }; static WORD_MEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39592,13 +75740,21 @@ static WORD_MEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("anism"), + dictgen::InsensitiveStr::Ascii("anisms"), 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"), @@ -39622,17 +75778,31 @@ pub static WORD_MEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["mechanism"], &["mechanisms"], &["mercenaries"], &["mercenary"], + &["mechanism"], + &["mechanisms"], + &["mechanism"], &["mechanical"], &["mechanically"], &["mechanics"], @@ -39647,19 +75817,50 @@ pub static WORD_MEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["mechanisms"], &["mechanics"], &["mechanism"], - &["mechanism"], + &["mechanism", "mechanisms"], &["mechanic"], &["mechanic"], - &["mechanics"], + &["mechanics", "mechanism"], &["mechanism"], &["mechanism"], &["mechanisms"], &["mechanism"], &["mechanisms"], + &["machine"], + &["machines"], &["mechanical"], + &["mechanism"], + &["mechanisms"], + &["mechanism"], + &["mechanism"], &["mechanisms"], ], - range: 5..=10, + range: 4..=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 { @@ -39669,30 +75870,90 @@ static WORD_MEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("chanism"), + dictgen::InsensitiveStr::Ascii("chanisms"), + dictgen::InsensitiveStr::Ascii("chinism"), + dictgen::InsensitiveStr::Ascii("chinisms"), + dictgen::InsensitiveStr::Ascii("chnism"), + dictgen::InsensitiveStr::Ascii("chnisms"), + dictgen::InsensitiveStr::Ascii("ding"), dictgen::InsensitiveStr::Ascii("gthread"), dictgen::InsensitiveStr::Ascii("gtron"), + dictgen::InsensitiveStr::Ascii("ing"), dictgen::InsensitiveStr::Ascii("ncing"), + dictgen::InsensitiveStr::Ascii("nigfull"), + dictgen::InsensitiveStr::Ascii("nign"), + dictgen::InsensitiveStr::Ascii("nin"), + dictgen::InsensitiveStr::Ascii("ninful"), dictgen::InsensitiveStr::Ascii("ningess"), + dictgen::InsensitiveStr::Ascii("ningfull"), dictgen::InsensitiveStr::Ascii("ningles"), + dictgen::InsensitiveStr::Ascii("nining"), + dictgen::InsensitiveStr::Ascii("ninless"), dictgen::InsensitiveStr::Ascii("ninng"), dictgen::InsensitiveStr::Ascii("nins"), + dictgen::InsensitiveStr::Ascii("r"), + dictgen::InsensitiveStr::Ascii("rly"), + dictgen::InsensitiveStr::Ascii("surd"), + dictgen::InsensitiveStr::Ascii("suremenet"), + dictgen::InsensitiveStr::Ascii("suremenets"), + dictgen::InsensitiveStr::Ascii("surmenet"), + dictgen::InsensitiveStr::Ascii("surmenets"), + dictgen::InsensitiveStr::Ascii("surment"), + dictgen::InsensitiveStr::Ascii("surments"), + dictgen::InsensitiveStr::Ascii("tadata"), dictgen::InsensitiveStr::Ascii("tballers"), dictgen::InsensitiveStr::Ascii("tballls"), dictgen::InsensitiveStr::Ascii("tbals"), + dictgen::InsensitiveStr::Ascii("tfile"), + dictgen::InsensitiveStr::Ascii("thod"), + dictgen::InsensitiveStr::Ascii("uring"), + dictgen::InsensitiveStr::Ascii("usure"), + dictgen::InsensitiveStr::Ascii("usures"), ], values: &[ + &["mechanism"], + &["mechanisms"], + &["mechanism"], + &["mechanisms"], + &["mechanism"], + &["mechanisms"], + &["meaning"], &["megathread"], &["megatron"], + &["meaning"], &["menacing"], + &["meaningful"], + &["meaning"], + &["meaning"], + &["meaningful"], &["meanings"], + &["meaningful"], &["meanings"], &["meaning"], + &["meaningless"], + &["meaning"], &["meanings"], + &["wear", "mere", "mare"], + &["merely", "nearly"], + &["measured", "measure"], + &["measurement"], + &["measurements"], + &["measurement"], + &["measurements"], + &["measurement"], + &["measurements"], + &["metadata"], &["meatballs"], &["meatballs"], &["meatballs"], + &["metafile"], + &["method"], + &["measuring"], + &["measure"], + &["measures"], ], - range: 4..=8, + range: 1..=10, }; static WORD_MD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39704,9 +75965,24 @@ pub static WORD_MD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("ifielder"), dictgen::InsensitiveStr::Ascii("ifielders"), + dictgen::InsensitiveStr::Ascii("oel"), + dictgen::InsensitiveStr::Ascii("oeled"), + dictgen::InsensitiveStr::Ascii("oeling"), + dictgen::InsensitiveStr::Ascii("oelled"), + dictgen::InsensitiveStr::Ascii("oelling"), + dictgen::InsensitiveStr::Ascii("oels"), ], - values: &[&["midfielder"], &["midfielders"]], - range: 8..=9, + values: &[ + &["midfielder"], + &["midfielders"], + &["model"], + &["modeled"], + &["modeling"], + &["modelled"], + &["modelling"], + &["models"], + ], + range: 3..=9, }; static WORD_MC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39721,9 +75997,20 @@ pub static WORD_MC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"], @@ -39731,11 +76018,22 @@ pub static WORD_MC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["mccarthy"], &["mccarthyist"], &["mcgregor"], + &["mechanic"], + &["mechanical"], + &["mechanically"], + &["mechanicals"], &["mechanics"], + &["mechanism"], + &["mechanisms"], &["mclaren"], &["mcgregor"], + &["microscope"], + &["microscopes"], + &["microscopic"], + &["microscopies"], + &["microscopy"], ], - range: 5..=8, + range: 5..=9, }; static WORD_MA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39744,14 +76042,14 @@ static WORD_MA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + 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), - None, + Some(&WORD_MAH_NODE), Some(&WORD_MAI_NODE), Some(&WORD_MAJ_NODE), Some(&WORD_MAK_NODE), @@ -39759,19 +76057,30 @@ static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_MAM_NODE), Some(&WORD_MAN_NODE), None, - None, + Some(&WORD_MAP_NODE), None, Some(&WORD_MAR_NODE), Some(&WORD_MAS_NODE), Some(&WORD_MAT_NODE), Some(&WORD_MAU_NODE), - None, + Some(&WORD_MAV_NODE), None, Some(&WORD_MAX_NODE), Some(&WORD_MAY_NODE), - None, + 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, @@ -39782,6 +76091,7 @@ pub static WORD_MAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("alsia"), dictgen::InsensitiveStr::Ascii("alsian"), dictgen::InsensitiveStr::Ascii("balline"), + dictgen::InsensitiveStr::Ascii("bee"), dictgen::InsensitiveStr::Ascii("belle"), dictgen::InsensitiveStr::Ascii("belleine"), dictgen::InsensitiveStr::Ascii("bellene"), @@ -39792,11 +76102,13 @@ pub static WORD_MAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("billine"), dictgen::InsensitiveStr::Ascii("lasia"), dictgen::InsensitiveStr::Ascii("lasian"), + dictgen::InsensitiveStr::Ascii("u"), ], values: &[ &["malaysia"], &["malaysian"], &["maybelline"], + &["maybe"], &["maybelline"], &["maybelline"], &["maybelline"], @@ -39807,8 +76119,9 @@ pub static WORD_MAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["maybelline"], &["malaysia"], &["malaysian"], + &["may"], ], - range: 5..=8, + range: 1..=8, }; static WORD_MAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -39819,11 +76132,44 @@ static WORD_MAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_MAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("imazing"), + dictgen::InsensitiveStr::Ascii("imim"), + dictgen::InsensitiveStr::Ascii("imimum"), dictgen::InsensitiveStr::Ascii("imini"), + dictgen::InsensitiveStr::Ascii("imium"), dictgen::InsensitiveStr::Ascii("imixing"), + dictgen::InsensitiveStr::Ascii("imun"), + dictgen::InsensitiveStr::Ascii("inum"), + dictgen::InsensitiveStr::Ascii("ium"), + dictgen::InsensitiveStr::Ascii("iumum"), + dictgen::InsensitiveStr::Ascii("osx"), + dictgen::InsensitiveStr::Ascii("umum"), ], - values: &[&["maximizing"], &["maximizing"], &["maximizing"]], - range: 5..=7, + values: &[ + &["maximizing"], + &["maximum"], + &["maximum"], + &["maximizing"], + &["maximum"], + &["maximizing"], + &["maximum"], + &["maximum"], + &["maximum"], + &["maximum"], + &["macosx"], + &["maximum"], + ], + range: 3..=7, +}; + +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 { @@ -39834,79 +76180,256 @@ static WORD_MAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["manuals"]], - range: 4..=5, + values: &[&["marauder"], &["maybe", "mauve"], &["manuals"]], + range: 2..=5, }; static WORD_MAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MAT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_MAT_CHILDREN), value: None, }; -pub static WORD_MAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aphorical"), - dictgen::InsensitiveStr::Ascii("aphorically"), - dictgen::InsensitiveStr::Ascii("aphysical"), - dictgen::InsensitiveStr::Ascii("chamking"), - dictgen::InsensitiveStr::Ascii("chmakeing"), - dictgen::InsensitiveStr::Ascii("eralists"), - dictgen::InsensitiveStr::Ascii("eriaal"), - dictgen::InsensitiveStr::Ascii("eriales"), - dictgen::InsensitiveStr::Ascii("erialisimo"), - dictgen::InsensitiveStr::Ascii("erialsim"), - dictgen::InsensitiveStr::Ascii("erialsm"), - dictgen::InsensitiveStr::Ascii("erias"), - dictgen::InsensitiveStr::Ascii("hamatician"), - dictgen::InsensitiveStr::Ascii("hamatics"), - dictgen::InsensitiveStr::Ascii("hametician"), - dictgen::InsensitiveStr::Ascii("hameticians"), - dictgen::InsensitiveStr::Ascii("hcmaking"), - dictgen::InsensitiveStr::Ascii("hcup"), - dictgen::InsensitiveStr::Ascii("hcups"), - dictgen::InsensitiveStr::Ascii("hemagically"), - dictgen::InsensitiveStr::Ascii("hemagics"), - dictgen::InsensitiveStr::Ascii("hemathics"), - dictgen::InsensitiveStr::Ascii("hematicals"), - dictgen::InsensitiveStr::Ascii("hematicaly"), - dictgen::InsensitiveStr::Ascii("hematican"), - dictgen::InsensitiveStr::Ascii("hematicans"), - dictgen::InsensitiveStr::Ascii("hematicas"), - dictgen::InsensitiveStr::Ascii("hematicion"), - dictgen::InsensitiveStr::Ascii("hematicks"), - dictgen::InsensitiveStr::Ascii("hematicly"), - dictgen::InsensitiveStr::Ascii("hematisch"), - dictgen::InsensitiveStr::Ascii("hematitian"), - dictgen::InsensitiveStr::Ascii("hematitians"), - dictgen::InsensitiveStr::Ascii("hemetical"), - dictgen::InsensitiveStr::Ascii("hemetically"), - dictgen::InsensitiveStr::Ascii("hemetician"), - dictgen::InsensitiveStr::Ascii("hemeticians"), - dictgen::InsensitiveStr::Ascii("hemetics"), - dictgen::InsensitiveStr::Ascii("heticians"), - dictgen::InsensitiveStr::Ascii("hewes"), - dictgen::InsensitiveStr::Ascii("himatical"), - dictgen::InsensitiveStr::Ascii("himatically"), - dictgen::InsensitiveStr::Ascii("himatics"), - dictgen::InsensitiveStr::Ascii("hmatically"), - dictgen::InsensitiveStr::Ascii("hmatician"), - dictgen::InsensitiveStr::Ascii("hmaticians"), - dictgen::InsensitiveStr::Ascii("hwes"), - dictgen::InsensitiveStr::Ascii("ieral"), - dictgen::InsensitiveStr::Ascii("ieralism"), - dictgen::InsensitiveStr::Ascii("ierals"), - dictgen::InsensitiveStr::Ascii("rial"), - dictgen::InsensitiveStr::Ascii("terss"), - dictgen::InsensitiveStr::Ascii("treses"), + dictgen::InsensitiveStr::Ascii("erss"), + dictgen::InsensitiveStr::Ascii("reses"), + ], + values: &[&["mattress"], &["mattress"]], + range: 4..=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("ial")], + values: &[&["martial"]], + range: 3..=3, +}; + +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("x"), + ], + values: &[&["material"], &["materialism"], &["materials"], &["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("ces"), + 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("wes"), ], values: &[ - &["metaphorical"], - &["metaphorically"], - &["metaphysical"], - &["matchmaking"], + &["mathematician"], + &["mathematics"], + &["mathematician"], + &["mathematicians"], + &["matches"], + &["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"], + &["mathews"], + ], + range: 2..=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"], @@ -39914,49 +76437,69 @@ pub static WORD_MAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["materialism"], &["materialism"], &["materials"], - &["mathematician"], - &["mathematics"], - &["mathematician"], - &["mathematicians"], - &["matchmaking"], - &["matchup"], - &["matchups"], - &["mathematically"], - &["mathematics"], - &["mathematics"], - &["mathematics"], - &["mathematically"], - &["mathematician"], - &["mathematics"], - &["mathematics"], - &["mathematician"], - &["mathematics"], - &["mathematical"], - &["mathematics"], - &["mathematician"], - &["mathematicians"], - &["mathematical"], - &["mathematically"], - &["mathematician"], - &["mathematicians"], - &["mathematics"], - &["mathematicians"], - &["mathews"], - &["mathematical"], - &["mathematically"], - &["mathematics"], - &["mathematically"], - &["mathematician"], - &["mathematicians"], - &["mathews"], + &["materials", "material"], &["material"], &["materialism"], + &["materialize"], + &["materials"], + &["material"], &["materials"], - &["martial"], - &["mattress"], - &["mattress"], ], - range: 4..=11, + 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("hmakeing"), + dictgen::InsensitiveStr::Ascii("hs"), + dictgen::InsensitiveStr::Ascii("ing"), + ], + values: &[ + &["matchmaking"], + &["matches"], + &["matching"], + &["matching"], + &["matchmaking"], + &["matches"], + &["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 { @@ -39972,16 +76515,16 @@ static WORD_MAS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, + Some(&WORD_MASH_NODE), + Some(&WORD_MASI_NODE), None, - None, - None, - None, + Some(&WORD_MASK_NODE), None, None, None, Some(&WORD_MASO_NODE), None, - None, + Some(&WORD_MASQ_NODE), Some(&WORD_MASR_NODE), Some(&WORD_MASS_NODE), Some(&WORD_MAST_NODE), @@ -40011,6 +76554,7 @@ static WORD_MAST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -40025,6 +76569,7 @@ pub static WORD_MAST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -40059,6 +76604,7 @@ pub static WORD_MAST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("utbation"), ], values: &[ + &["master"], &["masteries"], &["masturbation"], &["masteries"], @@ -40073,6 +76619,7 @@ pub static WORD_MAST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["masterpiece"], &["masterpiece"], &["masteries"], + &["masquerade"], &["masturbate"], &["masturbated"], &["masturbate"], @@ -40106,7 +76653,7 @@ pub static WORD_MAST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["masterpiece"], &["masturbation"], ], - range: 4..=9, + range: 3..=9, }; static WORD_MASS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -40130,13 +76677,17 @@ pub static WORD_MASS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ter"), ], values: &[ &["massacre"], @@ -40153,13 +76704,17 @@ pub static WORD_MASS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["massachusetts"], &["massachusetts"], &["massacre"], + &["messagebox"], &["massages"], &["massacre"], &["massages"], &["massacre"], &["massachusetts"], + &["mastectomy"], + &["masseur"], &["massively"], &["massively"], + &["master"], ], range: 3..=12, }; @@ -40175,6 +76730,20 @@ pub static WORD_MASR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -40184,9 +76753,55 @@ pub static WORD_MASO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ginistic"), dictgen::InsensitiveStr::Ascii("gynistic"), + dictgen::InsensitiveStr::Ascii("s"), ], - values: &[&["misogynistic"], &["misogynistic"]], - range: 8..=8, + 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 { @@ -40216,9 +76831,12 @@ static WORD_MASA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_MASA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("cra")], - values: &[&["mascara"]], - range: 3..=3, + 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 { @@ -40297,9 +76915,10 @@ pub static WORD_MART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ail"), dictgen::InsensitiveStr::Ascii("ain"), + dictgen::InsensitiveStr::Ascii("er"), ], - values: &[&["martial"], &["martian"]], - range: 3..=3, + values: &[&["martial"], &["martian"], &["martyr"]], + range: 2..=3, }; static WORD_MARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -40410,7 +77029,7 @@ pub static WORD_MARK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["markers"], &["marketplace"], &["markers"], - &["marks"], + &["marks", "marked", "markers"], &["marketplace"], &["marketing"], ], @@ -40438,6 +77057,7 @@ static WORD_MARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -40455,6 +77075,7 @@ pub static WORD_MARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("yln"), ], values: &[ + &["mariadb"], &["marriage"], &["marines"], &["marginal"], @@ -40501,13 +77122,16 @@ pub static WORD_MARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -40519,18 +77143,21 @@ pub static WORD_MARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["margaret"], &["margaret"], &["marginalized"], + &["merger", "marker"], &["margaret"], + &["mergers", "markers"], &["marginally"], &["marginal"], &["marginal"], &["marginal"], &["marginally"], &["margins"], + &["margin", "merging"], &["margins"], &["marginalized"], &["margins"], ], - range: 3..=8, + range: 2..=8, }; static WORD_MARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -40594,6 +77221,37 @@ pub static WORD_MARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("peds"), + dictgen::InsensitiveStr::Ascii("pping"), + dictgen::InsensitiveStr::Ascii("ppings"), + ], + values: &[ + &["mappable"], + &["map"], + &["mapped"], + &["mapping"], + &["mappings"], + &["map"], + &["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, @@ -40624,139 +77282,265 @@ static WORD_MAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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_MANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_MANU_CHILDREN), +static WORD_MANUV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_MANUV_CHILDREN), value: None, }; -pub static WORD_MANU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ales"), - dictgen::InsensitiveStr::Ascii("aly"), - dictgen::InsensitiveStr::Ascii("ever"), - dictgen::InsensitiveStr::Ascii("evers"), - dictgen::InsensitiveStr::Ascii("facter"), - dictgen::InsensitiveStr::Ascii("factered"), - dictgen::InsensitiveStr::Ascii("facterer"), - dictgen::InsensitiveStr::Ascii("facterers"), - dictgen::InsensitiveStr::Ascii("facteres"), - dictgen::InsensitiveStr::Ascii("factering"), - dictgen::InsensitiveStr::Ascii("facters"), - dictgen::InsensitiveStr::Ascii("facterurs"), - dictgen::InsensitiveStr::Ascii("facteur"), - dictgen::InsensitiveStr::Ascii("facteurs"), - dictgen::InsensitiveStr::Ascii("factored"), - dictgen::InsensitiveStr::Ascii("factorer"), - dictgen::InsensitiveStr::Ascii("factorers"), - dictgen::InsensitiveStr::Ascii("factores"), - dictgen::InsensitiveStr::Ascii("factoring"), - dictgen::InsensitiveStr::Ascii("factued"), - dictgen::InsensitiveStr::Ascii("factuer"), - dictgen::InsensitiveStr::Ascii("factuered"), - dictgen::InsensitiveStr::Ascii("factuerer"), - dictgen::InsensitiveStr::Ascii("factueres"), - dictgen::InsensitiveStr::Ascii("factuers"), - dictgen::InsensitiveStr::Ascii("factuing"), - dictgen::InsensitiveStr::Ascii("facturas"), - dictgen::InsensitiveStr::Ascii("facturedd"), - dictgen::InsensitiveStr::Ascii("factureds"), - dictgen::InsensitiveStr::Ascii("factureers"), - dictgen::InsensitiveStr::Ascii("factureras"), - dictgen::InsensitiveStr::Ascii("facturerd"), - dictgen::InsensitiveStr::Ascii("facturered"), - dictgen::InsensitiveStr::Ascii("facturerers"), - dictgen::InsensitiveStr::Ascii("factureres"), - dictgen::InsensitiveStr::Ascii("factureros"), - dictgen::InsensitiveStr::Ascii("facturier"), - dictgen::InsensitiveStr::Ascii("facturor"), - dictgen::InsensitiveStr::Ascii("facturors"), - dictgen::InsensitiveStr::Ascii("facturs"), - dictgen::InsensitiveStr::Ascii("factuter"), - dictgen::InsensitiveStr::Ascii("factuters"), - dictgen::InsensitiveStr::Ascii("facure"), - dictgen::InsensitiveStr::Ascii("facuter"), - dictgen::InsensitiveStr::Ascii("facuters"), - dictgen::InsensitiveStr::Ascii("facutre"), - dictgen::InsensitiveStr::Ascii("facutred"), - dictgen::InsensitiveStr::Ascii("facutrers"), - dictgen::InsensitiveStr::Ascii("facutres"), - dictgen::InsensitiveStr::Ascii("fature"), - dictgen::InsensitiveStr::Ascii("fatured"), - dictgen::InsensitiveStr::Ascii("faturing"), - dictgen::InsensitiveStr::Ascii("fcaturers"), - dictgen::InsensitiveStr::Ascii("pilated"), - dictgen::InsensitiveStr::Ascii("pilating"), - dictgen::InsensitiveStr::Ascii("pulating"), - dictgen::InsensitiveStr::Ascii("pulation"), - dictgen::InsensitiveStr::Ascii("pulative"), - dictgen::InsensitiveStr::Ascii("ver"), + 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: &[ - &["manuals"], - &["manually"], - &["maneuver"], - &["maneuvers"], - &["manufacture"], - &["manufactured"], - &["manufacturer"], - &["manufacturers"], - &["manufactures"], - &["manufacturing"], - &["manufactures"], - &["manufactures"], - &["manufactures"], - &["manufactures"], - &["manufactured"], - &["manufacturer"], - &["manufacturers"], - &["manufactures"], - &["manufacturing"], - &["manufactured"], - &["manufacture"], - &["manufactured"], - &["manufacturer"], - &["manufactures"], - &["manufacturers"], - &["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"], - &["manufactures"], &["manipulated"], &["manipulating"], + &["manipulations"], + &["manipulate"], + &["manipulated"], + &["manipulates"], &["manipulating"], &["manipulation"], + &["manipulations"], &["manipulative"], - &["maneuver"], ], - range: 3..=11, + 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("ly"), + ], + values: &[&["manually"], &["manually"]], + range: 2..=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("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"], + &["manufactured"], + &["manufacturer"], + &["manufactures"], + &["manufacturers"], + &["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("ver"), + dictgen::InsensitiveStr::Ascii("vers"), + ], + values: &[ + &["manual"], + &["manually"], + &["maneuver", "maneuver"], + &["maneuvers", "maneuvers"], + ], + range: 2..=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 { @@ -40765,9 +77549,33 @@ static WORD_MANT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_MANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ained")], - values: &[&["maintained"]], - range: 5..=5, + 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 { @@ -40801,6 +77609,7 @@ static WORD_MANO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -40808,10 +77617,11 @@ pub static WORD_MANO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["maneuverability"], - &["maneuver"], - &["maneuverability"], - &["maneuverable"], - &["maneuvers"], + &["manoeuvring"], + &["maneuver", "maneuver"], + &["maneuverability", "maneuverability"], + &["maneuverable", "maneuverable"], + &["maneuvers", "maneuvers"], ], range: 4..=12, }; @@ -40826,15 +77636,23 @@ pub static WORD_MANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: 6..=7, + range: 2..=7, }; static WORD_MANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -40844,12 +77662,14 @@ static WORD_MANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -40888,17 +77708,23 @@ pub static WORD_MANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -40928,7 +77754,7 @@ pub static WORD_MANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["manipulate"], &["manipulate"], &["manipulative"], - &["manipulation"], + &["manipulation", "manipulating"], &["manipulating"], &["manipulation"], &["manipulate"], @@ -40937,9 +77763,13 @@ pub static WORD_MANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["manifestations"], &["manipulate"], &["manipulated"], + &["manipulates"], &["manipulating"], &["manipulation"], + &["manipulations"], &["manipulative"], + &["manipulator"], + &["manipulators"], ], range: 4..=11, }; @@ -40951,7 +77781,15 @@ static WORD_MANG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("esium"), dictgen::InsensitiveStr::Ascii("etic"), dictgen::InsensitiveStr::Ascii("ets"), @@ -40959,14 +77797,22 @@ pub static WORD_MANG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("lade"), ], values: &[ + &["managed"], + &["management"], + &["manager", "manger"], + &["managers", "mangers"], + &["manager"], + &["managers"], &["mangled"], + &["management"], + &["management"], &["magnesium"], &["magnetic"], &["magnets"], &["magnitude"], &["mangled"], ], - range: 3..=5, + range: 3..=6, }; static WORD_MANF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -40999,6 +77845,7 @@ pub static WORD_MANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("agable"), dictgen::InsensitiveStr::Ascii("festation"), + dictgen::InsensitiveStr::Ascii("ment"), dictgen::InsensitiveStr::Ascii("ouvre"), dictgen::InsensitiveStr::Ascii("ouvred"), dictgen::InsensitiveStr::Ascii("ouvres"), @@ -41013,6 +77860,7 @@ pub static WORD_MANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["manageable"], &["manifestation"], + &["management"], &["manoeuvre"], &["manoeuvred"], &["manoeuvres"], @@ -41039,7 +77887,9 @@ pub static WORD_MAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("arion"), dictgen::InsensitiveStr::Ascii("ase"), dictgen::InsensitiveStr::Ascii("aste"), + dictgen::InsensitiveStr::Ascii("atatory"), dictgen::InsensitiveStr::Ascii("ats"), + dictgen::InsensitiveStr::Ascii("etory"), dictgen::InsensitiveStr::Ascii("rain"), dictgen::InsensitiveStr::Ascii("rian"), ], @@ -41049,11 +77899,13 @@ pub static WORD_MAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["mandarin"], &["mandates"], &["mandates"], + &["mandatory"], &["mandates"], + &["mandatory"], &["mandarin"], &["mandarin"], ], - range: 3..=5, + range: 3..=7, }; static WORD_MANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41071,8 +77923,19 @@ pub static WORD_MANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("gmenet"), dictgen::InsensitiveStr::Ascii("gment"), + 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"), ], @@ -41084,13 +77947,24 @@ pub static WORD_MANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["manufactures"], &["manufacturing"], &["manifestation"], - &["manageable"], - &["manageable"], + &["manageable", "manageably"], &["management"], + &["manageable"], + &["managed"], + &["management"], + &["management"], + &["management"], + &["management"], + &["manual"], + &["manage"], + &["management"], + &["manager"], + &["managers"], + &["manual"], &["manually"], &["manuals"], ], - range: 3..=9, + range: 1..=9, }; static WORD_MAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41100,11 +77974,13 @@ static WORD_MAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ory"), ], - values: &[&["mammal"], &["mammalian"]], - range: 2..=5, + values: &[&["management"], &["mammal"], &["mammalian"], &["memory"]], + range: 2..=7, }; static WORD_MAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41124,6 +78000,7 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -41132,6 +78009,10 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("funciton"), dictgen::InsensitiveStr::Ascii("functing"), dictgen::InsensitiveStr::Ascii("funktion"), + dictgen::InsensitiveStr::Ascii("icous"), + dictgen::InsensitiveStr::Ascii("icously"), + dictgen::InsensitiveStr::Ascii("place"), + dictgen::InsensitiveStr::Ascii("placed"), dictgen::InsensitiveStr::Ascii("practce"), dictgen::InsensitiveStr::Ascii("practise"), dictgen::InsensitiveStr::Ascii("practive"), @@ -41150,6 +78031,7 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["malaysia"], &["malaysian"], &["malcolm"], + &["malcolm"], &["melatonin"], &["malfunction"], &["malfunction"], @@ -41158,6 +78040,10 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["malfunction"], &["malfunction"], &["malfunction"], + &["malicious"], + &["maliciously"], + &["misplace"], + &["misplaced"], &["malpractice"], &["malpractice"], &["malpractice"], @@ -41165,7 +78051,7 @@ pub static WORD_MAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["malaysia"], &["malaysian"], ], - range: 4..=9, + range: 3..=9, }; static WORD_MAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41175,12 +78061,34 @@ static WORD_MAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), ], - values: &[&["marked"], &["marksman"], &["makes"]], - range: 2..=5, + values: &[ + &["make"], + &["marked", "made"], + &["makefile"], + &["making"], + &["making"], + &["macro"], + &["macros"], + &["makes", "makers", "macros"], + &["marksman"], + &["mask", "masks", "makes", "make"], + &["makes", "masks"], + &["masks", "makes"], + ], + range: 1..=5, }; static WORD_MAJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41201,12 +78109,18 @@ static WORD_MAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -41220,10 +78134,15 @@ pub static WORD_MAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ntan"), dictgen::InsensitiveStr::Ascii("ntanance"), dictgen::InsensitiveStr::Ascii("ntance"), + dictgen::InsensitiveStr::Ascii("ntane"), dictgen::InsensitiveStr::Ascii("ntanence"), + dictgen::InsensitiveStr::Ascii("ntaner"), + dictgen::InsensitiveStr::Ascii("ntaners"), + dictgen::InsensitiveStr::Ascii("ntans"), dictgen::InsensitiveStr::Ascii("ntenace"), dictgen::InsensitiveStr::Ascii("ntenaince"), dictgen::InsensitiveStr::Ascii("ntenence"), + dictgen::InsensitiveStr::Ascii("ntiain"), dictgen::InsensitiveStr::Ascii("ntian"), dictgen::InsensitiveStr::Ascii("ntianed"), dictgen::InsensitiveStr::Ascii("ntianing"), @@ -41232,16 +78151,28 @@ pub static WORD_MAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["manifest"], &["manifestation"], &["manifesto"], &["manifests"], + &["mainly"], + &["mailing"], &["manipulate"], &["mainstream"], &["mainstream"], @@ -41255,10 +78186,15 @@ pub static WORD_MAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["maintain"], &["maintenance"], &["maintenance"], + &["maintain"], + &["maintenance"], + &["maintainer"], + &["maintainers"], + &["maintains"], &["maintenance"], &["maintenance"], &["maintenance"], - &["maintenance"], + &["maintain"], &["maintain"], &["maintained"], &["maintaining"], @@ -41267,10 +78203,27 @@ pub static WORD_MAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["maintenance"], &["maintenance"], &["mentioned"], + &["mariadb"], + &["mariadb"], &["marijuana"], &["marilyn"], + &["maintain"], + &["maintenance"], + &["maintained"], + &["maintainers"], ], - range: 3..=10, + 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 { @@ -41284,6 +78237,7 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -41293,6 +78247,8 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -41314,6 +78270,7 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["magazine"], &["magazines"], &["magnesium"], + &["magenta", "magnet"], &["magnetic"], &["magnets"], &["magician"], @@ -41323,6 +78280,8 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["magnitude"], &["magazine"], &["magazine"], + &["magnitude"], + &["magnitude"], &["magnificent"], &["magnesium"], &["magnesium"], @@ -41339,7 +78298,7 @@ pub static WORD_MAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["magnitude"], &["magnolia"], ], - range: 4..=9, + range: 3..=9, }; static WORD_MAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41360,11 +78319,21 @@ static WORD_MAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["madison"], &["masturbating"], &["masturbation"]], + values: &[ + &["mandatory"], + &["mandatory"], + &["madness"], + &["madison"], + &["masturbating"], + &["masturbation"], + ], range: 4..=9, }; @@ -41377,26 +78346,54 @@ pub static WORD_MAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("arino"), dictgen::InsensitiveStr::Ascii("aronni"), + 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("hiens"), + dictgen::InsensitiveStr::Ascii("hinary"), 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: &[ &["macaroni"], &["macaroni"], + &["macro"], + &["macros"], + &["mechanism"], + &["mechanisms"], + &["matched"], + &["matches"], &["machines"], - &["machine"], + &["machinery"], + &["machine", "marching", "matching"], &["machines"], &["mackerel"], &["malcolm"], + &["macro"], + &["macro"], + &["macros"], + &["package"], + &["macros"], + &["macro"], + &["matching"], &["matchup"], &["matchups"], ], - range: 4..=6, + range: 1..=7, }; static WORD_MAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41405,9 +78402,24 @@ static WORD_MAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_MAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("yelline")], - values: &[&["maybelline"]], - range: 7..=7, + 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")], + values: &[&["make"]], + range: 2..=2, }; static WORD_L_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41418,7 +78430,7 @@ static WORD_L_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_LA_NODE), None, - None, + Some(&WORD_LC_NODE), None, Some(&WORD_LE_NODE), Some(&WORD_LF_NODE), @@ -41426,15 +78438,15 @@ static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_LI_NODE), None, - None, + Some(&WORD_LK_NODE), None, Some(&WORD_LM_NODE), Some(&WORD_LN_NODE), Some(&WORD_LO_NODE), + Some(&WORD_LP_NODE), None, None, - None, - None, + Some(&WORD_LS_NODE), None, Some(&WORD_LU_NODE), Some(&WORD_LV_NODE), @@ -41493,6 +78505,8 @@ pub static WORD_LU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -41514,113 +78528,510 @@ pub static WORD_LU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["ludicrous"], &["lucifer"], &["lieutenant"], - &["likud"], + &["likud", "lucid"], + &["luminous"], + &["luminosity"], &["lunatics"], &["lunatics"], &["lunatics"], ], - range: 3..=8, + range: 3..=9, }; -static WORD_LO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_LO_CHILDREN), +static WORD_LS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_LS_CHILDREN), value: None, }; -pub static WORD_LO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_LS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("adous"), - dictgen::InsensitiveStr::Ascii("bbyistes"), - dictgen::InsensitiveStr::Ascii("bbysits"), - dictgen::InsensitiveStr::Ascii("ckacreen"), - dictgen::InsensitiveStr::Ascii("ckscreeen"), - dictgen::InsensitiveStr::Ascii("ckscren"), - dictgen::InsensitiveStr::Ascii("enard"), - dictgen::InsensitiveStr::Ascii("epard"), - dictgen::InsensitiveStr::Ascii("ev"), - dictgen::InsensitiveStr::Ascii("gictical"), - dictgen::InsensitiveStr::Ascii("gisitcal"), - dictgen::InsensitiveStr::Ascii("gisitcs"), - dictgen::InsensitiveStr::Ascii("gisticas"), - dictgen::InsensitiveStr::Ascii("gisticly"), - dictgen::InsensitiveStr::Ascii("giteh"), - dictgen::InsensitiveStr::Ascii("gsitics"), - dictgen::InsensitiveStr::Ascii("gtiech"), - dictgen::InsensitiveStr::Ascii("iusiana"), - dictgen::InsensitiveStr::Ascii("iusville"), - dictgen::InsensitiveStr::Ascii("llipoop"), - dictgen::InsensitiveStr::Ascii("llipoopy"), - dictgen::InsensitiveStr::Ascii("nelyness"), - dictgen::InsensitiveStr::Ascii("ngevitity"), - dictgen::InsensitiveStr::Ascii("ngevitiy"), - dictgen::InsensitiveStr::Ascii("ngitme"), - dictgen::InsensitiveStr::Ascii("ngitudonal"), - dictgen::InsensitiveStr::Ascii("ngtiem"), - dictgen::InsensitiveStr::Ascii("nileness"), - dictgen::InsensitiveStr::Ascii("nley"), - dictgen::InsensitiveStr::Ascii("nlieness"), - dictgen::InsensitiveStr::Ascii("nly"), - dictgen::InsensitiveStr::Ascii("oseley"), - dictgen::InsensitiveStr::Ascii("osley"), - dictgen::InsensitiveStr::Ascii("replay"), - dictgen::InsensitiveStr::Ascii("tharingen"), - dictgen::InsensitiveStr::Ascii("uieville"), - dictgen::InsensitiveStr::Ascii("uisiania"), - dictgen::InsensitiveStr::Ascii("uisianna"), - dictgen::InsensitiveStr::Ascii("uisivlle"), - dictgen::InsensitiveStr::Ascii("uisviile"), - dictgen::InsensitiveStr::Ascii("uisvile"), - dictgen::InsensitiveStr::Ascii("uisvillle"), - dictgen::InsensitiveStr::Ascii("usiville"), + dictgen::InsensitiveStr::Ascii("at"), + dictgen::InsensitiveStr::Ascii("it"), + dictgen::InsensitiveStr::Ascii("its"), ], values: &[ - &["loadouts"], - &["lobbyists"], - &["lobbyists"], - &["lockscreen"], - &["lockscreen"], - &["lockscreen"], - &["leonard"], - &["leopard"], - &["love"], - &["logistical"], - &["logistical"], - &["logistics"], - &["logistics"], - &["logistical"], - &["logitech"], - &["logistics"], - &["logitech"], + &["last", "slat", "sat"], + &["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, + None, +]; + +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("d")], + values: &[&["load", "low", "loud"]], + range: 1..=1, +}; + +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"], - &["lollipop"], - &["lollipop"], + &["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("ted"), + ], + values: &[ + &["lost", "loss", "lose", "load"], + &["loosely"], + &["loosen"], + &["loosened"], + &["listed", "lost", "lasted"], + ], + range: 1..=4, +}; + +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("bpack"), + 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"], + &["looks"], + &["looking"], + &["loop"], + &["lookup"], + &["loosely"], + &["loosely"], + &["loosely"], + &["lossy", "lousy"], + ], + range: 2..=5, +}; + +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("gitute"), + dictgen::InsensitiveStr::Ascii("gst"), + dictgen::InsensitiveStr::Ascii("gtiem"), + dictgen::InsensitiveStr::Ascii("guer"), + dictgen::InsensitiveStr::Ascii("ileness"), + dictgen::InsensitiveStr::Ascii("ley"), + dictgen::InsensitiveStr::Ascii("lieness"), + dictgen::InsensitiveStr::Ascii("ly"), + ], + values: &[ + &["longer"], + &["long"], &["loneliness"], + &["longer", "lounge"], + &["longer"], &["longevity"], &["longevity"], &["longtime"], &["longitudinal"], + &["longitude"], + &["longitude"], + &["longest"], &["longtime"], + &["longer"], &["loneliness"], &["lonely"], &["loneliness"], - &["lonely"], - &["loosely"], - &["loosely"], - &["roleplay"], - &["lothringen"], - &["louisville"], - &["louisiana"], - &["louisiana"], - &["louisville"], - &["louisville"], - &["louisville"], - &["louisville"], - &["louisville"], + &["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("lipoop"), + dictgen::InsensitiveStr::Ascii("lipoopy"), + ], + values: &[&["total"], &["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("aly"), + ], + values: &[&["local"], &["locale"], &["locally"]], + range: 2..=3, +}; + +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("usiana"), + dictgen::InsensitiveStr::Ascii("usville"), + ], + values: &[&["login"], &["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("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("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("oic"), + dictgen::InsensitiveStr::Ascii("rithm"), + dictgen::InsensitiveStr::Ascii("sitics"), + dictgen::InsensitiveStr::Ascii("tiech"), + dictgen::InsensitiveStr::Ascii("writter"), + ], + values: &[ + &["logarithmically"], + &["logarithmic"], + &["logical"], + &["logged", "lodged", "longed"], + &["logger", "lodger", "longer"], + &["logging"], + &["login", "logging"], + &["logically"], + &["logitech"], + &["logistical"], + &["logfile"], + &["logging", "lodging"], + &["logistical"], + &["logistics"], + &["logistics"], + &["logistical"], + &["logitech"], + &["longitude"], + &["logic"], + &["logarithm"], + &["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("ing")], + values: &[&["loading"]], + range: 3..=3, +}; + +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("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("alzation"), + dictgen::InsensitiveStr::Ascii("atins"), + dictgen::InsensitiveStr::Ascii("cked"), + dictgen::InsensitiveStr::Ascii("gical"), + dictgen::InsensitiveStr::Ascii("kacreen"), + dictgen::InsensitiveStr::Ascii("kingf"), + dictgen::InsensitiveStr::Ascii("kscreeen"), + dictgen::InsensitiveStr::Ascii("kscren"), + ], + values: &[ + &["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"], + &["localization"], + &["locations"], + &["locked"], + &["logical"], + &["lockscreen"], + &["locking"], + &["lockscreen"], + &["lockscreen"], + ], + range: 2..=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, @@ -41643,6 +79054,17 @@ pub static WORD_LM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg range: 3..=3, }; +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, @@ -41660,7 +79082,7 @@ static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_LIK_NODE), - None, + Some(&WORD_LIL_NODE), Some(&WORD_LIM_NODE), Some(&WORD_LIN_NODE), Some(&WORD_LIO_NODE), @@ -41674,9 +79096,24 @@ static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, 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, @@ -41685,6 +79122,8 @@ static WORD_LIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -41693,12 +79132,15 @@ pub static WORD_LIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -41707,11 +79149,12 @@ pub static WORD_LIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["livestream"], &["livestream"], &["livestream"], + &["lifetime"], &["livelihood"], &["lively"], &["livelihood"], ], - range: 3..=7, + range: 2..=7, }; static WORD_LIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41735,7 +79178,11 @@ static WORD_LIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -41763,10 +79210,21 @@ pub static WORD_LIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -41777,6 +79235,10 @@ pub static WORD_LIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("uhania"), ], values: &[ + &["literal"], + &["literally"], + &["literals"], + &["literature"], &["literature"], &["litecoin"], &["litecoin"], @@ -41805,10 +79267,21 @@ pub static WORD_LIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["litigation"], &["litigation"], &["lithium"], + &["little"], &["littlefinger"], + &["liquid"], + &["liquids"], + &["list"], + &["little"], + &["little"], &["little"], &["littlefinger"], &["literally"], + &["literal"], + &["literally"], + &["literals"], + &["literate"], + &["literature"], &["littlefinger"], &["littlefinger"], &["littlefinger"], @@ -41818,7 +79291,7 @@ pub static WORD_LIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["littlefinger"], &["lithuania"], ], - range: 3..=9, + range: 1..=9, }; static WORD_LIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41832,28 +79305,48 @@ pub static WORD_LIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tenend"), dictgen::InsensitiveStr::Ascii("teneres"), dictgen::InsensitiveStr::Ascii("tenes"), + dictgen::InsensitiveStr::Ascii("tensers"), + dictgen::InsensitiveStr::Ascii("tenter"), + dictgen::InsensitiveStr::Ascii("tenters"), dictgen::InsensitiveStr::Ascii("tents"), + dictgen::InsensitiveStr::Ascii("ternes"), + dictgen::InsensitiveStr::Ascii("tner"), dictgen::InsensitiveStr::Ascii("tners"), ], values: &[ - &["license"], - &["licence"], + &["license", "license"], + &["licence", "licence"], &["silenced"], - &["license"], + &["license", "license"], + &["listening"], + &["listing"], &["lipsticks"], + &["listpack"], + &["listbox"], + &["listening"], &["listened"], &["listened"], &["listeners"], &["listens"], + &["listeners"], + &["listener"], + &["listeners"], &["listens"], &["listeners"], + &["listener"], + &["listeners"], ], - range: 4..=7, + range: 3..=7, }; static WORD_LIQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41878,9 +79371,12 @@ static WORD_LIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_LIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("stics")], - values: &[&["lipsticks"]], - range: 5..=5, + 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 { @@ -41901,13 +79397,22 @@ static WORD_LIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_LIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("erisation"), + dictgen::InsensitiveStr::Ascii("erisations"), 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"), @@ -41921,17 +79426,31 @@ pub static WORD_LIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("gusitic"), dictgen::InsensitiveStr::Ascii("gusitics"), dictgen::InsensitiveStr::Ascii("gvistic"), + dictgen::InsensitiveStr::Ascii("height"), + 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: &[ + &["license"], + &["licensed"], + &["licenses"], &["lincoln"], &["lincoln"], &["lincoln"], + &["linearly", "linearity"], + &["linearisation"], + &["linearisations"], &["lineups"], + &["linewidth"], + &["lines"], &["lingerie"], &["lingerie"], &["lingerie"], + &["length"], &["linguistics"], &["linguistics"], &["linguistics"], @@ -41945,10 +79464,15 @@ pub static WORD_LIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["linguistics"], &["linguistics"], &["linguistic"], + &["lineheight"], + &["linked"], + &["linkify"], &["linnaean"], + &["lintian"], &["lineups"], + &["lines"], ], - range: 4..=9, + range: 1..=10, }; static WORD_LIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -41959,15 +79483,43 @@ static WORD_LIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_LIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ination"), + dictgen::InsensitiveStr::Ascii("inted"), dictgen::InsensitiveStr::Ascii("itacion"), + dictgen::InsensitiveStr::Ascii("itaion"), 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("k"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("ti"), + dictgen::InsensitiveStr::Ascii("ts"), ], values: &[ + &["limitation"], + &["limited"], &["limitation"], &["limitation"], &["limitation"], @@ -41976,22 +79528,66 @@ pub static WORD_LIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["limitation"], &["limitation"], &["limitation"], + &["limit"], + &["limitation"], + &["limitations"], + &["limitation"], + &["limitations"], + &["limited"], + &["limiter"], + &["limiters"], + &["limiting"], + &["limiting"], + &["limitation"], + &["limitations"], + &["limits"], + &["limitation"], + &["limitations"], + &["limited"], + &["limiter"], + &["limiters"], + &["limiting"], + &["limited"], + &["link"], + &["limited"], + &["limit"], + &["limits"], ], - range: 5..=8, + 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: None, + 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("elyhood"), + dictgen::InsensitiveStr::Ascii("ewis"), + dictgen::InsensitiveStr::Ascii("ly"), ], - values: &[&["likeable"], &["likelihood"]], - range: 5..=7, + values: &[ + &["likeable"], + &["likely"], + &["likelihood"], + &["likewise"], + &["likely"], + ], + range: 2..=7, }; static WORD_LIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42001,6 +79597,9 @@ static WORD_LIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("hitng"), dictgen::InsensitiveStr::Ascii("hlty"), @@ -42025,11 +79624,14 @@ pub static WORD_LIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("itation"), + dictgen::InsensitiveStr::Ascii("th"), dictgen::InsensitiveStr::Ascii("thening"), dictgen::InsensitiveStr::Ascii("thers"), dictgen::InsensitiveStr::Ascii("thhouse"), @@ -42040,6 +79642,9 @@ pub static WORD_LIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("thweight"), ], values: &[ + &["light", "lie", "lye"], + &["lighter", "liar", "liger"], + &["lighters", "liars", "ligers"], &["lightening"], &["lighting"], &["lightly"], @@ -42068,7 +79673,10 @@ pub static WORD_LIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["lightweight"], &["lightweight"], &["lightweight"], + &["lightweight"], + &["lightweight"], &["litigation"], + &["light"], &["lightening"], &["lighters"], &["lighthouse"], @@ -42078,7 +79686,7 @@ pub static WORD_LIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["lightroom"], &["lightweight"], ], - range: 4..=10, + range: 1..=10, }; static WORD_LIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42088,7 +79696,10 @@ static WORD_LIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -42102,7 +79713,10 @@ pub static WORD_LIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("time"), ], values: &[ + &["lifecycle"], + &["lifecycle"], &["lifespan"], + &["lives"], &["lifespan"], &["lifesteal"], &["lifestyles"], @@ -42115,7 +79729,7 @@ pub static WORD_LIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["lifestyles"], &["lifetime"], ], - range: 4..=7, + range: 2..=7, }; static WORD_LIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42131,6 +79745,7 @@ pub static WORD_LIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("k"), dictgen::InsensitiveStr::Ascii("kable"), dictgen::InsensitiveStr::Ascii("kd"), + dictgen::InsensitiveStr::Ascii("nt"), dictgen::InsensitiveStr::Ascii("nups"), dictgen::InsensitiveStr::Ascii("sure"), dictgen::InsensitiveStr::Ascii("tuenant"), @@ -42141,6 +79756,7 @@ pub static WORD_LIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("utenent"), dictgen::InsensitiveStr::Ascii("utennant"), dictgen::InsensitiveStr::Ascii("utentant"), + dictgen::InsensitiveStr::Ascii("v"), dictgen::InsensitiveStr::Ascii("ved"), ], values: &[ @@ -42150,6 +79766,7 @@ pub static WORD_LIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["like"], &["likable"], &["liked"], + &["client", "clients"], &["lineups"], &["leisure"], &["lieutenant"], @@ -42160,6 +79777,7 @@ pub static WORD_LIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["lieutenant"], &["lieutenant"], &["lieutenant"], + &["live"], &["lived"], ], range: 1..=8, @@ -42172,138 +79790,318 @@ static WORD_LIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("enceing"), dictgen::InsensitiveStr::Ascii("encie"), dictgen::InsensitiveStr::Ascii("encse"), + dictgen::InsensitiveStr::Ascii("ese"), ], - values: &[&["licence"], &["licence"]], - range: 5..=5, + values: &[ + &["locate"], + &["located"], + &["location"], + &["locations"], + &["licencing"], + &["licence"], + &["licence"], + &["license"], + ], + range: 3..=7, }; static WORD_LIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_LIB_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_LIB_CHILDREN), value: None, }; -pub static WORD_LIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ary"), - dictgen::InsensitiveStr::Ascii("eracion"), - dictgen::InsensitiveStr::Ascii("erae"), - dictgen::InsensitiveStr::Ascii("erales"), - dictgen::InsensitiveStr::Ascii("eralest"), - dictgen::InsensitiveStr::Ascii("eralim"), - dictgen::InsensitiveStr::Ascii("eralis"), - dictgen::InsensitiveStr::Ascii("eralisim"), - dictgen::InsensitiveStr::Ascii("eralizm"), - dictgen::InsensitiveStr::Ascii("eralnim"), - dictgen::InsensitiveStr::Ascii("eralsim"), - dictgen::InsensitiveStr::Ascii("erarion"), - dictgen::InsensitiveStr::Ascii("eras"), - dictgen::InsensitiveStr::Ascii("eraties"), - dictgen::InsensitiveStr::Ascii("eratin"), - dictgen::InsensitiveStr::Ascii("erato"), - dictgen::InsensitiveStr::Ascii("eratore"), - dictgen::InsensitiveStr::Ascii("eratrian"), - dictgen::InsensitiveStr::Ascii("eratrianism"), - dictgen::InsensitiveStr::Ascii("eratrians"), - dictgen::InsensitiveStr::Ascii("ertae"), - dictgen::InsensitiveStr::Ascii("ertairan"), - dictgen::InsensitiveStr::Ascii("ertania"), - dictgen::InsensitiveStr::Ascii("ertarain"), - dictgen::InsensitiveStr::Ascii("ertarainism"), - dictgen::InsensitiveStr::Ascii("ertarains"), - dictgen::InsensitiveStr::Ascii("ertariaism"), - dictgen::InsensitiveStr::Ascii("ertarianisim"), - dictgen::InsensitiveStr::Ascii("ertarianisme"), - dictgen::InsensitiveStr::Ascii("ertarianismo"), - dictgen::InsensitiveStr::Ascii("ertarianists"), - dictgen::InsensitiveStr::Ascii("ertariansim"), - dictgen::InsensitiveStr::Ascii("ertariansism"), - dictgen::InsensitiveStr::Ascii("ertariansm"), - dictgen::InsensitiveStr::Ascii("ertarias"), - dictgen::InsensitiveStr::Ascii("ertarien"), - dictgen::InsensitiveStr::Ascii("ertariens"), - dictgen::InsensitiveStr::Ascii("ertarinaism"), - dictgen::InsensitiveStr::Ascii("ertaryan"), - dictgen::InsensitiveStr::Ascii("ertaryanism"), - dictgen::InsensitiveStr::Ascii("ertaryans"), - dictgen::InsensitiveStr::Ascii("ertatian"), - dictgen::InsensitiveStr::Ascii("ertatianism"), - dictgen::InsensitiveStr::Ascii("ertatians"), - dictgen::InsensitiveStr::Ascii("ertea"), - dictgen::InsensitiveStr::Ascii("erterian"), - dictgen::InsensitiveStr::Ascii("erterianism"), - dictgen::InsensitiveStr::Ascii("erterians"), - dictgen::InsensitiveStr::Ascii("guistic"), - dictgen::InsensitiveStr::Ascii("guistics"), - dictgen::InsensitiveStr::Ascii("itarianisn"), - dictgen::InsensitiveStr::Ascii("le"), - dictgen::InsensitiveStr::Ascii("raires"), - dictgen::InsensitiveStr::Ascii("rarse"), - dictgen::InsensitiveStr::Ascii("retarian"), - dictgen::InsensitiveStr::Ascii("retarianism"), - dictgen::InsensitiveStr::Ascii("retarians"), + 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("aris"), + dictgen::InsensitiveStr::Ascii("arries"), + dictgen::InsensitiveStr::Ascii("arry"), + dictgen::InsensitiveStr::Ascii("arse"), + 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"), ], values: &[ &["library"], - &["liberation"], - &["liberate"], - &["liberals"], - &["liberate"], - &["liberalism"], - &["liberals"], - &["liberalism"], - &["liberalism"], - &["liberalism"], - &["liberalism"], - &["liberation"], - &["liberals"], - &["liberate"], - &["liberation"], - &["liberation"], - &["liberate"], - &["libertarians"], - &["libertarianism"], - &["libertarians"], - &["liberate"], - &["libertarians"], - &["libertarians"], + &["libraries"], + &["library"], + &["library"], + &["libraries"], + &["library"], + &["library"], + &["libraries"], + &["library"], + &["libraries"], + &["library"], + &["library"], + &["library"], + &["library"], + &["libraries"], + &["libraries"], + &["library"], + &["libraries"], + &["libraries"], + &["library"], + &["library"], + &["libraries"], + &["library"], + &["libraries"], + &["libraries"], + &["library"], + &["libraries"], + &["library"], + &["libraries"], + &["library"], + &["library"], + &["library"], + &["libreoffice"], + &["libreofficekit"], + &["libraries"], + &["library"], &["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"], - &["linguistic"], - &["linguistics"], - &["libertarianism"], + &["libraries"], + ], + 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("rarion"), + 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"], - &["libraries"], - &["libraries"], + &["liberation"], + &["liberate"], + &["liberals"], + &["liberate"], + &["liberalism"], + &["liberals"], + &["liberalism"], + &["liberalism"], + &["liberalism"], + &["liberalism"], + &["liberation"], + &["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..=12, + 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 { @@ -42313,11 +80111,12 @@ static WORD_LIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["liaison"], &["liaison"], &["liaisons"]], + values: &[&["liars"], &["liaison"], &["liaison"], &["liaisons"]], range: 3..=4, }; @@ -42361,11 +80160,38 @@ static WORD_LE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_LEU_NODE), Some(&WORD_LEV_NODE), None, - None, - None, + 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")], + values: &[&["lexical"]], + range: 3..=3, +}; + static WORD_LEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_LEV_CHILDREN), value: None, @@ -42373,6 +80199,7 @@ static WORD_LEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("elign"), @@ -42383,11 +80210,13 @@ pub static WORD_LEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["leveling"], @@ -42399,10 +80228,11 @@ pub static WORD_LEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["leviathan"], &["leviticus"], &["level"], + &["level"], &["leveling"], &["leveling"], ], - range: 2..=7, + range: 1..=7, }; static WORD_LEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42425,9 +80255,13 @@ static WORD_LET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_LET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ivicus")], - values: &[&["leviticus"]], - range: 6..=6, + 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 { @@ -42446,6 +80280,7 @@ pub static WORD_LES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("iban"), dictgen::InsensitiveStr::Ascii("ibans"), dictgen::InsensitiveStr::Ascii("iure"), + dictgen::InsensitiveStr::Ascii("stiff"), ], values: &[ &["lesbian"], @@ -42457,6 +80292,7 @@ pub static WORD_LES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["lesbian"], &["lesbians"], &["leisure"], + &["lesstif"], ], range: 4..=7, }; @@ -42469,10 +80305,21 @@ static WORD_LER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["learns"]], - range: 2..=3, + values: &[ + &["learn"], + &["learned"], + &["learns"], + &["learn", "lean"], + &["learned", "learned", "leaned"], + &["learning", "leaning"], + ], + range: 1..=4, }; static WORD_LEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42494,25 +80341,73 @@ static WORD_LEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_LEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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("iant"), + dictgen::InsensitiveStr::Ascii("inent"), 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: &[ &["legendaries"], &["length"], + &["length"], &["lengths"], + &["length"], + &["lengthen"], + &["lengthened"], + &["lengthened"], + &["lengthening"], + &["length"], + &["lengthen"], &["lengths"], &["lengthy"], + &["lengthy"], + &["lengths"], + &["lengthy"], + &["length"], + &["lengthen"], + &["longtext"], + &["lengths"], + &["length"], + &["lengthy"], + &["lengths"], + &["lenient"], + &["lenient"], &["leonard"], + &["length"], + &["lengths"], + &["length"], + &["lengths"], &["lentils"], &["lentils"], ], - range: 3..=8, + range: 2..=8, }; static WORD_LEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42522,98 +80417,144 @@ static WORD_LEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["legions"], &["lieutenant"]], - range: 4..=7, + values: &[ + &["leibniz"], + &["lightweight"], + &["legions"], + &["lieutenant"], + ], + range: 4..=9, }; static WORD_LEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_LEG_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_LEG_CHILDREN), value: None, }; -pub static WORD_LEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_LEG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_LEGA_NODE), + None, + None, + None, + Some(&WORD_LEGE_NODE), + None, + None, + None, + 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")], + values: &[&["length"]], + range: 1..=1, +}; + +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("alazing"), - dictgen::InsensitiveStr::Ascii("alizacion"), - dictgen::InsensitiveStr::Ascii("alizaing"), - dictgen::InsensitiveStr::Ascii("alizaiton"), - dictgen::InsensitiveStr::Ascii("alizare"), - dictgen::InsensitiveStr::Ascii("alizate"), - dictgen::InsensitiveStr::Ascii("alizaton"), - dictgen::InsensitiveStr::Ascii("alizeing"), - dictgen::InsensitiveStr::Ascii("enadries"), - dictgen::InsensitiveStr::Ascii("endaies"), - dictgen::InsensitiveStr::Ascii("endaires"), - dictgen::InsensitiveStr::Ascii("endarios"), - dictgen::InsensitiveStr::Ascii("endaris"), - dictgen::InsensitiveStr::Ascii("endarisk"), - dictgen::InsensitiveStr::Ascii("endariske"), - dictgen::InsensitiveStr::Ascii("endaryes"), - dictgen::InsensitiveStr::Ascii("enday"), - dictgen::InsensitiveStr::Ascii("enderies"), - dictgen::InsensitiveStr::Ascii("ilsation"), - dictgen::InsensitiveStr::Ascii("imitacy"), - dictgen::InsensitiveStr::Ascii("imitate"), - dictgen::InsensitiveStr::Ascii("imitately"), - dictgen::InsensitiveStr::Ascii("ionis"), - dictgen::InsensitiveStr::Ascii("islacion"), - dictgen::InsensitiveStr::Ascii("islatie"), - dictgen::InsensitiveStr::Ascii("islatiors"), - dictgen::InsensitiveStr::Ascii("islativo"), - dictgen::InsensitiveStr::Ascii("istation"), - dictgen::InsensitiveStr::Ascii("istative"), - dictgen::InsensitiveStr::Ascii("istators"), - dictgen::InsensitiveStr::Ascii("istration"), - dictgen::InsensitiveStr::Ascii("itamacy"), - dictgen::InsensitiveStr::Ascii("itamate"), - dictgen::InsensitiveStr::Ascii("itamately"), - dictgen::InsensitiveStr::Ascii("itamicy"), - dictgen::InsensitiveStr::Ascii("itamite"), - dictgen::InsensitiveStr::Ascii("itamitely"), - dictgen::InsensitiveStr::Ascii("itemacy"), - dictgen::InsensitiveStr::Ascii("itemate"), - dictgen::InsensitiveStr::Ascii("itemately"), - dictgen::InsensitiveStr::Ascii("itematly"), - dictgen::InsensitiveStr::Ascii("itimaly"), - dictgen::InsensitiveStr::Ascii("itimancy"), - dictgen::InsensitiveStr::Ascii("itimatcy"), - dictgen::InsensitiveStr::Ascii("itimatelly"), - dictgen::InsensitiveStr::Ascii("itimatley"), - dictgen::InsensitiveStr::Ascii("itimatly"), - dictgen::InsensitiveStr::Ascii("itimetly"), - dictgen::InsensitiveStr::Ascii("itimicy"), - dictgen::InsensitiveStr::Ascii("itimite"), - dictgen::InsensitiveStr::Ascii("itimitely"), - dictgen::InsensitiveStr::Ascii("itimt"), - dictgen::InsensitiveStr::Ascii("itmate"), - dictgen::InsensitiveStr::Ascii("nedaries"), - dictgen::InsensitiveStr::Ascii("nedary"), - dictgen::InsensitiveStr::Ascii("nths"), - dictgen::InsensitiveStr::Ascii("nthy"), - dictgen::InsensitiveStr::Ascii("oins"), + dictgen::InsensitiveStr::Ascii("edaries"), + dictgen::InsensitiveStr::Ascii("edary"), + dictgen::InsensitiveStr::Ascii("th"), + dictgen::InsensitiveStr::Ascii("ths"), + dictgen::InsensitiveStr::Ascii("thy"), ], values: &[ - &["legalizing"], - &["legalization"], - &["legalizing"], - &["legalization"], - &["legalize"], - &["legalize"], - &["legalization"], - &["legalizing"], - &["legendaries"], - &["legendaries"], - &["legendaries"], - &["legendaries"], - &["legendaries"], - &["legendaries"], - &["legendaries"], &["legendaries"], &["legendary"], - &["legendaries"], + &["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("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"], @@ -42644,18 +80585,86 @@ pub static WORD_LEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["legitimately"], &["legitimately"], &["legitimately"], + &["legitimately"], &["legitimacy"], &["legitimate"], &["legitimately"], &["legitimate"], &["legitimate"], + ], + range: 4..=9, +}; + +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"], - &["lengths"], - &["lengthy"], - &["legions"], + &["legendaries"], ], - range: 4..=10, + 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 { @@ -42722,22 +80731,84 @@ static WORD_LEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("nr"), + dictgen::InsensitiveStr::Ascii("ry"), + dictgen::InsensitiveStr::Ascii("set"), + 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"], - &["lean"], + &["lean", "learn", "leaner"], + &["leery"], + &["least"], + &["lead", "leak", "least", "leaf"], &["lethal"], + &["least"], + &["leaving"], + &["leaving"], ], - range: 2..=9, + 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 { @@ -42754,7 +80825,7 @@ static WORD_LA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_LAG_NODE), None, - None, + Some(&WORD_LAI_NODE), None, None, None, @@ -42780,9 +80851,12 @@ static WORD_LAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_LAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("yness")], - values: &[&["laziness"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("yness"), + ], + values: &[&["laser"], &["laziness"]], + range: 2..=5, }; static WORD_LAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42818,10 +80892,23 @@ static WORD_LAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("elling"), + dictgen::InsensitiveStr::Ascii("els"), dictgen::InsensitiveStr::Ascii("endr"), ], - values: &[&["larvae"], &["lavender"]], - range: 2..=4, + values: &[ + &["larvae"], + &["level", "laravel"], + &["leveled"], + &["leveling"], + &["levelling"], + &["levels"], + &["lavender"], + ], + range: 2..=6, }; static WORD_LAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42831,6 +80918,11 @@ static WORD_LAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -42839,12 +80931,20 @@ pub static WORD_LAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ghablely"), dictgen::InsensitiveStr::Ascii("ghabley"), dictgen::InsensitiveStr::Ascii("ghablly"), + 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("nhed"), ], values: &[ + &["launch"], + &["launched"], + &["launcher"], + &["launches"], + &["launching"], &["launched"], &["launcher"], &["launchers"], @@ -42853,12 +80953,15 @@ pub static WORD_LAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["laughably"], &["laughably"], &["laughably"], + &["language"], &["launched"], &["launching"], + &["launch", "launches"], + &["launch"], &["laundry"], &["launched"], ], - range: 4..=8, + range: 2..=8, }; static WORD_LAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42869,21 +80972,35 @@ static WORD_LAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("titude"), ], values: &[ &["alteration"], + &["later", "latest"], + &["latest"], + &["latin"], + &["latitude"], + &["latitude"], &["latitude"], &["latitude"], &["latitude"], &["lantern"], + &["laptops"], + &["latest"], &["latitude"], ], - range: 4..=7, + range: 2..=7, }; static WORD_LAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42897,6 +81014,9 @@ pub static WORD_LAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("agnia"), dictgen::InsensitiveStr::Ascii("anga"), dictgen::InsensitiveStr::Ascii("gana"), + dictgen::InsensitiveStr::Ascii("o"), + dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("test"), dictgen::InsensitiveStr::Ascii("tr"), ], values: &[ @@ -42904,9 +81024,12 @@ pub static WORD_LAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["lasagna"], &["lasagna"], &["lasagna"], + &["also", "lasso"], + &["latest"], + &["latest"], &["last"], ], - range: 2..=5, + range: 1..=5, }; static WORD_LAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42918,6 +81041,9 @@ pub static WORD_LAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("eady"), dictgen::InsensitiveStr::Ascii("egly"), + dictgen::InsensitiveStr::Ascii("g"), + dictgen::InsensitiveStr::Ascii("get"), + dictgen::InsensitiveStr::Ascii("gets"), dictgen::InsensitiveStr::Ascii("gley"), dictgen::InsensitiveStr::Ascii("gst"), dictgen::InsensitiveStr::Ascii("ington"), @@ -42927,13 +81053,16 @@ pub static WORD_LAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["already"], &["largely"], + &["large"], + &["larger", "largest", "target"], + &["largest", "targets"], &["largely"], &["largest"], &["arlington"], &["larry"], &["lawrence"], ], - range: 3..=6, + range: 1..=6, }; static WORD_LAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42942,9 +81071,25 @@ static WORD_LAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_LAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("douts")], - values: &[&["loadouts"]], - range: 5..=5, + 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("ut"), + ], + values: &[ + &["load"], + &["loaded"], + &["loading"], + &["loadouts"], + &["loads"], + &["laotian"], + &["layout"], + ], + range: 1..=5, }; static WORD_LAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -42954,6 +81099,8 @@ static WORD_LAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_LAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("aguage"), + dictgen::InsensitiveStr::Ascii("auge"), dictgen::InsensitiveStr::Ascii("dacapes"), dictgen::InsensitiveStr::Ascii("dingers"), dictgen::InsensitiveStr::Ascii("dins"), @@ -42962,20 +81109,59 @@ pub static WORD_LAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dscspe"), dictgen::InsensitiveStr::Ascii("dshapes"), dictgen::InsensitiveStr::Ascii("dspaces"), + dictgen::InsensitiveStr::Ascii("gage"), + dictgen::InsensitiveStr::Ascii("gauage"), dictgen::InsensitiveStr::Ascii("gauge"), dictgen::InsensitiveStr::Ascii("gauges"), + dictgen::InsensitiveStr::Ascii("geuage"), + dictgen::InsensitiveStr::Ascii("geuagesection"), + dictgen::InsensitiveStr::Ascii("guace"), + dictgen::InsensitiveStr::Ascii("guaces"), + dictgen::InsensitiveStr::Ascii("guae"), + dictgen::InsensitiveStr::Ascii("guaes"), dictgen::InsensitiveStr::Ascii("guague"), + dictgen::InsensitiveStr::Ascii("guahe"), + dictgen::InsensitiveStr::Ascii("guahes"), + dictgen::InsensitiveStr::Ascii("guaje"), + dictgen::InsensitiveStr::Ascii("guajes"), + dictgen::InsensitiveStr::Ascii("gual"), + dictgen::InsensitiveStr::Ascii("guale"), + dictgen::InsensitiveStr::Ascii("guales"), + dictgen::InsensitiveStr::Ascii("gualge"), + dictgen::InsensitiveStr::Ascii("gualges"), + dictgen::InsensitiveStr::Ascii("guange"), + dictgen::InsensitiveStr::Ascii("guanges"), + dictgen::InsensitiveStr::Ascii("guaqe"), + dictgen::InsensitiveStr::Ascii("guaqes"), + dictgen::InsensitiveStr::Ascii("guate"), + dictgen::InsensitiveStr::Ascii("guates"), + dictgen::InsensitiveStr::Ascii("guauge"), + dictgen::InsensitiveStr::Ascii("guauges"), + dictgen::InsensitiveStr::Ascii("guege"), + dictgen::InsensitiveStr::Ascii("gueges"), + dictgen::InsensitiveStr::Ascii("gugae"), + dictgen::InsensitiveStr::Ascii("gugaes"), + dictgen::InsensitiveStr::Ascii("gugage"), + dictgen::InsensitiveStr::Ascii("gugages"), + dictgen::InsensitiveStr::Ascii("guge"), + dictgen::InsensitiveStr::Ascii("guges"), + dictgen::InsensitiveStr::Ascii("gugue"), + dictgen::InsensitiveStr::Ascii("gugues"), dictgen::InsensitiveStr::Ascii("nasters"), dictgen::InsensitiveStr::Ascii("nesters"), dictgen::InsensitiveStr::Ascii("nistars"), dictgen::InsensitiveStr::Ascii("nsiters"), dictgen::InsensitiveStr::Ascii("tren"), + dictgen::InsensitiveStr::Ascii("uage"), dictgen::InsensitiveStr::Ascii("ucher"), dictgen::InsensitiveStr::Ascii("uchers"), dictgen::InsensitiveStr::Ascii("uches"), + dictgen::InsensitiveStr::Ascii("ugage"), dictgen::InsensitiveStr::Ascii("ugages"), ], values: &[ + &["language"], + &["language"], &["landscapes"], &["landings"], &["landings"], @@ -42985,19 +81171,67 @@ pub static WORD_LAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["landscapes"], &["landscapes"], &["language"], + &["language"], + &["language"], &["languages"], &["language"], + &["languagesection"], + &["language"], + &["languages"], + &["language"], + &["languages"], + &["language"], + &["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"], &["lannisters"], &["lannisters"], &["lannisters"], &["lannisters"], &["lantern"], + &["language"], &["launcher"], &["launchers"], &["launches"], + &["language"], &["languages"], ], - range: 4..=7, + range: 4..=13, +}; + +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 { @@ -43009,9 +81243,11 @@ pub static WORD_LAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("uage"), dictgen::InsensitiveStr::Ascii("uages"), + dictgen::InsensitiveStr::Ascii("uague"), + dictgen::InsensitiveStr::Ascii("uagues"), ], - values: &[&["language"], &["languages"]], - range: 4..=5, + values: &[&["language"], &["languages"], &["language"], &["languages"]], + range: 4..=6, }; static WORD_LAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43038,9 +81274,16 @@ pub static WORD_LAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("arotory"), dictgen::InsensitiveStr::Ascii("atory"), + 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("lels"), + dictgen::InsensitiveStr::Ascii("les"), + dictgen::InsensitiveStr::Ascii("ling"), dictgen::InsensitiveStr::Ascii("oratoy"), dictgen::InsensitiveStr::Ascii("oratroy"), dictgen::InsensitiveStr::Ascii("oraty"), @@ -43048,6 +81291,7 @@ pub static WORD_LAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -43055,10 +81299,17 @@ pub static WORD_LAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["laboratory"], - &["lavatory"], + &["lavatory", "laboratory"], + &["labeled"], + &["labeled"], &["lebanese"], &["labyrinth"], - &["labeled"], + &["labyrinth"], + &["label"], + &["labeled", "labeled"], + &["labels"], + &["labels"], + &["labeling", "labeling"], &["laboratory"], &["laboratory"], &["laboratory"], @@ -43066,12 +81317,13 @@ pub static WORD_LAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["laborers"], &["laboratory"], &["laboratory"], + &["laboriously"], &["laboratory"], &["labyrinth"], &["labyrinth"], &["labyrinth"], ], - range: 3..=7, + range: 2..=9, }; static WORD_K_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43114,9 +81366,12 @@ static WORD_KY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_KY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rptonite")], - values: &[&["kryptonite"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("rillic"), + dictgen::InsensitiveStr::Ascii("rptonite"), + ], + values: &[&["cyrillic"], &["kryptonite"]], + range: 6..=8, }; static WORD_KW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43137,6 +81392,19 @@ static WORD_KU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("berntes"), dictgen::InsensitiveStr::Ascii("birck"), dictgen::InsensitiveStr::Ascii("nckle"), dictgen::InsensitiveStr::Ascii("nckles"), @@ -43145,6 +81413,19 @@ pub static WORD_KU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ridsh"), ], values: &[ + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], + &["kubernetes"], &["kubrick"], &["knuckle"], &["knuckles"], @@ -43152,7 +81433,7 @@ pub static WORD_KU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["kurdish"], &["kurdish"], ], - range: 5..=6, + range: 5..=10, }; static WORD_KT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43212,6 +81493,7 @@ static WORD_KO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -43233,11 +81515,16 @@ pub static WORD_KO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ntamination"), dictgen::InsensitiveStr::Ascii("nversation"), dictgen::InsensitiveStr::Ascii("nw"), + dictgen::InsensitiveStr::Ascii("nwn"), dictgen::InsensitiveStr::Ascii("nws"), + 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"], @@ -43259,9 +81546,13 @@ pub static WORD_KO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["contamination"], &["conversation"], &["know"], + &["known"], &["knows"], + &["coordinate"], + &["coordinates"], &["coordination"], &["koreans"], + &["known"], ], range: 2..=12, }; @@ -43276,12 +81567,16 @@ pub static WORD_KN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("olwedgable"), dictgen::InsensitiveStr::Ascii("oweldgable"), dictgen::InsensitiveStr::Ascii("oweldge"), dictgen::InsensitiveStr::Ascii("oweldgeable"), dictgen::InsensitiveStr::Ascii("owladgable"), + dictgen::InsensitiveStr::Ascii("owlage"), + dictgen::InsensitiveStr::Ascii("owlageable"), dictgen::InsensitiveStr::Ascii("owldegable"), dictgen::InsensitiveStr::Ascii("owldgeable"), dictgen::InsensitiveStr::Ascii("owleagable"), @@ -43299,23 +81594,31 @@ pub static WORD_KN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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: &[ &["knockback"], &["kinetic"], &["knights"], + &["knife"], + &["know"], &["knockback"], &["knowledgable"], &["knowledgable"], &["knowledge"], &["knowledgeable"], &["knowledgable"], + &["knowledge"], + &["knowledgeable"], &["knowledgable"], &["knowledgable"], &["knowledgable"], @@ -43334,13 +81637,17 @@ pub static WORD_KN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["knowledgeable"], &["knowledge"], &["knowledgeable"], + &["knowledgeable"], &["knuckle"], &["knuckles"], &["know"], + &["knowing"], + &["knowingly"], &["knowledgable"], + &["known"], &["knows"], ], - range: 2..=11, + range: 1..=11, }; static WORD_KL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43349,9 +81656,14 @@ static WORD_KL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_KL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("enex")], - values: &[&["kleenex"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("enex"), + dictgen::InsensitiveStr::Ascii("ick"), + dictgen::InsensitiveStr::Ascii("icked"), + dictgen::InsensitiveStr::Ascii("icks"), + ], + values: &[&["kleenex"], &["click"], &["clicked"], &["clicks"]], + range: 3..=5, }; static WORD_KI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43438,50 +81750,134 @@ static WORD_KE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_KE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ept"), + dictgen::InsensitiveStr::Ascii("nel"), + dictgen::InsensitiveStr::Ascii("nels"), dictgen::InsensitiveStr::Ascii("nendy"), + dictgen::InsensitiveStr::Ascii("nerl"), + dictgen::InsensitiveStr::Ascii("nerls"), dictgen::InsensitiveStr::Ascii("neysian"), dictgen::InsensitiveStr::Ascii("nndey"), dictgen::InsensitiveStr::Ascii("nnedey"), + dictgen::InsensitiveStr::Ascii("nrel"), + dictgen::InsensitiveStr::Ascii("nrels"), dictgen::InsensitiveStr::Ascii("ntuckey"), dictgen::InsensitiveStr::Ascii("ntucy"), dictgen::InsensitiveStr::Ascii("nyesian"), + dictgen::InsensitiveStr::Ascii("pping"), + dictgen::InsensitiveStr::Ascii("pps"), + dictgen::InsensitiveStr::Ascii("renl"), + dictgen::InsensitiveStr::Ascii("renls"), + dictgen::InsensitiveStr::Ascii("rnal"), + dictgen::InsensitiveStr::Ascii("rnals"), + dictgen::InsensitiveStr::Ascii("rnerl"), + dictgen::InsensitiveStr::Ascii("rnerls"), + dictgen::InsensitiveStr::Ascii("t"), dictgen::InsensitiveStr::Ascii("tmaine"), + dictgen::InsensitiveStr::Ascii("word"), + dictgen::InsensitiveStr::Ascii("words"), + dictgen::InsensitiveStr::Ascii("wword"), + dictgen::InsensitiveStr::Ascii("wwords"), dictgen::InsensitiveStr::Ascii("ybaord"), dictgen::InsensitiveStr::Ascii("ybaords"), + dictgen::InsensitiveStr::Ascii("yboaard"), + dictgen::InsensitiveStr::Ascii("yboaards"), dictgen::InsensitiveStr::Ascii("yboad"), + dictgen::InsensitiveStr::Ascii("yboads"), dictgen::InsensitiveStr::Ascii("yboars"), + dictgen::InsensitiveStr::Ascii("ybooard"), + dictgen::InsensitiveStr::Ascii("ybooards"), dictgen::InsensitiveStr::Ascii("yborad"), + dictgen::InsensitiveStr::Ascii("yborads"), + dictgen::InsensitiveStr::Ascii("ybord"), + dictgen::InsensitiveStr::Ascii("ybords"), + dictgen::InsensitiveStr::Ascii("ybroad"), + dictgen::InsensitiveStr::Ascii("ybroads"), dictgen::InsensitiveStr::Ascii("ychan"), dictgen::InsensitiveStr::Ascii("ychian"), dictgen::InsensitiveStr::Ascii("yensian"), dictgen::InsensitiveStr::Ascii("yesnian"), + dictgen::InsensitiveStr::Ascii("yevente"), dictgen::InsensitiveStr::Ascii("ynode"), dictgen::InsensitiveStr::Ascii("ynseian"), + dictgen::InsensitiveStr::Ascii("yords"), + dictgen::InsensitiveStr::Ascii("youtch"), + dictgen::InsensitiveStr::Ascii("yowrd"), dictgen::InsensitiveStr::Ascii("ysenian"), + dictgen::InsensitiveStr::Ascii("ystokes"), + dictgen::InsensitiveStr::Ascii("yward"), + dictgen::InsensitiveStr::Ascii("ywoards"), + dictgen::InsensitiveStr::Ascii("ywork"), + dictgen::InsensitiveStr::Ascii("yworkd"), + dictgen::InsensitiveStr::Ascii("yworkds"), + dictgen::InsensitiveStr::Ascii("ywors"), + dictgen::InsensitiveStr::Ascii("ywprd"), ], values: &[ + &["kept"], + &["kernel", "kennel"], + &["kernels", "kennels"], &["kennedy"], + &["kernel"], + &["kernels"], &["keynesian"], &["kennedy"], &["kennedy"], + &["kernel"], + &["kernels"], &["kentucky"], &["kentucky"], &["keynesian"], + &["keeping"], + &["keeps"], + &["kernel"], + &["kernels"], + &["kernel"], + &["kernels"], + &["kernel"], + &["kernels"], + &["kept"], &["ketamine"], + &["keyword"], + &["keywords"], + &["keyword"], + &["keywords"], &["keyboard"], &["keyboards"], &["keyboard"], &["keyboards"], &["keyboard"], + &["keyboards"], + &["keyboards"], + &["keyboard"], + &["keyboards"], + &["keyboard"], + &["keyboards"], + &["keyboard"], + &["keyboards"], + &["keyboard"], + &["keyboards"], &["keychain"], &["keychain"], &["keynesian"], &["keynesian"], + &["keyevent"], &["keynote"], &["keynesian"], + &["keywords"], + &["keytouch"], + &["keyword"], &["keynesian"], + &["keystrokes"], + &["keyword"], + &["keywords"], + &["keyword"], + &["keyword"], + &["keywords"], + &["keywords"], + &["keyword"], ], - range: 5..=7, + range: 1..=8, }; static WORD_KA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43491,20 +81887,24 @@ static WORD_KA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_KA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ke"), dictgen::InsensitiveStr::Ascii("rakoe"), dictgen::InsensitiveStr::Ascii("rbohydrates"), dictgen::InsensitiveStr::Ascii("roake"), dictgen::InsensitiveStr::Ascii("tastrophic"), dictgen::InsensitiveStr::Ascii("temine"), + dictgen::InsensitiveStr::Ascii("zakstan"), ], values: &[ + &["cake", "take"], &["karaoke"], &["carbohydrates"], &["karaoke"], &["catastrophic"], &["ketamine"], + &["kazakhstan"], ], - range: 5..=11, + range: 2..=11, }; static WORD_J_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43521,14 +81921,14 @@ static WORD_J_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, None, None, - None, + Some(&WORD_JI_NODE), None, None, None, None, None, Some(&WORD_JO_NODE), - None, + Some(&WORD_JP_NODE), None, None, Some(&WORD_JS_NODE), @@ -43559,7 +81959,7 @@ static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, + Some(&WORD_JUM_NODE), Some(&WORD_JUN_NODE), None, Some(&WORD_JUP_NODE), @@ -43570,11 +81970,36 @@ static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_JUV_NODE), None, - 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, @@ -43593,15 +82018,19 @@ pub static WORD_JUV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict static WORD_JUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_JUS_CHILDREN), - value: None, + 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"), @@ -43614,12 +82043,17 @@ pub static WORD_JUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -43632,8 +82066,9 @@ pub static WORD_JUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["justify"], &["justifiable"], &["justifications"], + &["just"], ], - range: 4..=11, + range: 1..=11, }; static WORD_JUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43699,6 +82134,22 @@ pub static WORD_JUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 4..=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_JUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_JUI_CHILDREN), value: None, @@ -43720,6 +82171,7 @@ pub static WORD_JUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -43739,6 +82191,7 @@ pub static WORD_JUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["judgement"], &["judgemental"], &["judgements"], + &["judge"], &["juggernaut"], &["juggernaut"], &["juggernaut"], @@ -43754,7 +82207,7 @@ pub static WORD_JUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["juggernaut"], &["jungling"], ], - range: 5..=9, + range: 1..=9, }; static WORD_JUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43825,14 +82278,26 @@ static WORD_JS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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: &[&["just"], &["just"], &["justifications"]], + 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("ng")], + values: &[&["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, @@ -43841,11 +82306,16 @@ static WORD_JO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("rnal"), dictgen::InsensitiveStr::Ascii("runal"), dictgen::InsensitiveStr::Ascii("speh"), + dictgen::InsensitiveStr::Ascii("ssle"), dictgen::InsensitiveStr::Ascii("uney"), dictgen::InsensitiveStr::Ascii("unral"), dictgen::InsensitiveStr::Ascii("unralism"), @@ -43881,11 +82351,16 @@ pub static WORD_JO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg ], values: &[ &["jonathan"], + &["jodhpurs"], &["jeopardy"], &["johannine"], + &["joinable"], + &["joining"], &["jonathan"], &["journal"], + &["journal"], &["joseph"], + &["jostle"], &["journey"], &["journal"], &["journalism"], @@ -43922,6 +82397,20 @@ pub static WORD_JO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg range: 4..=13, }; +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("tterr"), + dictgen::InsensitiveStr::Ascii("tterring"), + ], + values: &[&["jitter"], &["jittering"]], + range: 5..=8, +}; + static WORD_JE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_JE_CHILDREN), value: None, @@ -43932,12 +82421,17 @@ pub static WORD_JE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("apardy"), dictgen::InsensitiveStr::Ascii("fferry"), dictgen::InsensitiveStr::Ascii("fferty"), + dictgen::InsensitiveStr::Ascii("ffies"), dictgen::InsensitiveStr::Ascii("ircho"), + dictgen::InsensitiveStr::Ascii("lous"), + dictgen::InsensitiveStr::Ascii("lousy"), + dictgen::InsensitiveStr::Ascii("lusey"), 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"), @@ -43948,18 +82442,24 @@ pub static WORD_JE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ruslaem"), dictgen::InsensitiveStr::Ascii("welrey"), dictgen::InsensitiveStr::Ascii("werly"), + dictgen::InsensitiveStr::Ascii("wl"), dictgen::InsensitiveStr::Ascii("wllery"), ], values: &[ &["jeopardy"], &["jeffery"], &["jeffery"], + &["jiffies"], &["jericho"], + &["jealous"], + &["jealousy"], + &["jealousy"], &["jennings"], &["jennings"], &["jeopardy"], &["jeopardy"], &["jeopardy"], + &["jeopardize"], &["jerseys"], &["jericho"], &["jerusalem"], @@ -43970,9 +82470,10 @@ pub static WORD_JE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["jerusalem"], &["jewelry"], &["jewelry"], + &["jew", "jewel"], &["jewellery"], ], - range: 5..=8, + range: 2..=8, }; static WORD_JA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -43986,9 +82487,11 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -43997,6 +82500,7 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -44008,23 +82512,37 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("miacan"), 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("paneese"), dictgen::InsensitiveStr::Ascii("panes"), + dictgen::InsensitiveStr::Ascii("panses"), dictgen::InsensitiveStr::Ascii("ques"), 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("vsscript"), ], values: &[ &["jacksonville"], &["jacksonville"], &["jacksonville"], &["jaguars"], + &["jagged"], &["jaguars"], &["jaguars"], &["jaguars"], + &["jaguar"], &["jailbroken"], &["jailbreak"], &["jailbreak"], @@ -44033,6 +82551,7 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["jamaican"], &["jailbreak"], &["jailbroken"], + &["jealousy", "jalousie"], &["jamaican"], &["jamaica"], &["jamaican"], @@ -44047,13 +82566,25 @@ pub static WORD_JA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["january"], &["january"], &["january"], + &["january"], + &["japanese"], + &["japanese"], &["japanese"], &["jacques"], &["jasmine"], &["jaguars"], &["january"], + &["javascript"], + &["javascript"], + &["javascript"], + &["javascript"], + &["javascript"], + &["javascript"], + &["javascript"], + &["java", "have"], + &["javascript"], ], - range: 4..=11, + range: 2..=11, }; static WORD_I_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44062,15 +82593,15 @@ static WORD_I_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di }; static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_IA_NODE), Some(&WORD_IB_NODE), Some(&WORD_IC_NODE), Some(&WORD_ID_NODE), Some(&WORD_IE_NODE), - None, + Some(&WORD_IF_NODE), Some(&WORD_IG_NODE), Some(&WORD_IH_NODE), - None, + Some(&WORD_II_NODE), None, None, Some(&WORD_IL_NODE), @@ -44083,7 +82614,7 @@ static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_IS_NODE), Some(&WORD_IT_NODE), Some(&WORD_IU_NODE), - None, + Some(&WORD_IV_NODE), Some(&WORD_IW_NODE), None, None, @@ -44097,11 +82628,23 @@ static WORD_IW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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: &[&["will"], &["with"]], - range: 2..=2, + 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("ocation")], + values: &[&["invocation"]], + range: 7..=7, }; static WORD_IU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44127,7 +82670,52 @@ pub static WORD_IT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("alianess"), dictgen::InsensitiveStr::Ascii("alianos"), dictgen::InsensitiveStr::Ascii("alias"), + dictgen::InsensitiveStr::Ascii("eartor"), + dictgen::InsensitiveStr::Ascii("eger"), + dictgen::InsensitiveStr::Ascii("egral"), + dictgen::InsensitiveStr::Ascii("egrals"), + dictgen::InsensitiveStr::Ascii("en"), + dictgen::InsensitiveStr::Ascii("ens"), + dictgen::InsensitiveStr::Ascii("ention"), + dictgen::InsensitiveStr::Ascii("entional"), + dictgen::InsensitiveStr::Ascii("entionally"), + dictgen::InsensitiveStr::Ascii("entionaly"), + dictgen::InsensitiveStr::Ascii("erater"), + dictgen::InsensitiveStr::Ascii("eratered"), + dictgen::InsensitiveStr::Ascii("eratons"), + dictgen::InsensitiveStr::Ascii("ereating"), + dictgen::InsensitiveStr::Ascii("erface"), + dictgen::InsensitiveStr::Ascii("erfaces"), + dictgen::InsensitiveStr::Ascii("erm"), + dictgen::InsensitiveStr::Ascii("ernations"), + dictgen::InsensitiveStr::Ascii("erpreter"), + dictgen::InsensitiveStr::Ascii("errupt"), + dictgen::InsensitiveStr::Ascii("ertation"), + dictgen::InsensitiveStr::Ascii("eself"), + dictgen::InsensitiveStr::Ascii("esm"), + dictgen::InsensitiveStr::Ascii("ialise"), + dictgen::InsensitiveStr::Ascii("ialised"), + dictgen::InsensitiveStr::Ascii("ialises"), + dictgen::InsensitiveStr::Ascii("ialising"), + dictgen::InsensitiveStr::Ascii("ialize"), + dictgen::InsensitiveStr::Ascii("ialized"), + dictgen::InsensitiveStr::Ascii("ializes"), + dictgen::InsensitiveStr::Ascii("ializing"), + dictgen::InsensitiveStr::Ascii("nerest"), + dictgen::InsensitiveStr::Ascii("nerface"), + dictgen::InsensitiveStr::Ascii("nerfaces"), + dictgen::InsensitiveStr::Ascii("nernal"), + dictgen::InsensitiveStr::Ascii("nervals"), dictgen::InsensitiveStr::Ascii("nroduced"), + dictgen::InsensitiveStr::Ascii("sef"), + dictgen::InsensitiveStr::Ascii("selfs"), + dictgen::InsensitiveStr::Ascii("selt"), + dictgen::InsensitiveStr::Ascii("selv"), + dictgen::InsensitiveStr::Ascii("sems"), + dictgen::InsensitiveStr::Ascii("slef"), + dictgen::InsensitiveStr::Ascii("slev"), + dictgen::InsensitiveStr::Ascii("teration"), + dictgen::InsensitiveStr::Ascii("terations"), ], values: &[ &["italians"], @@ -44135,181 +82723,622 @@ pub static WORD_IT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["italians"], &["italians"], &["italians"], + &["iterator"], + &["integer"], + &["integral"], + &["integrals"], + &["item"], + &["items"], + &["intention"], + &["intentional"], + &["intentionally"], + &["intentionally"], + &["iterator"], + &["iterated"], + &["iterations"], + &["iterating"], + &["interface"], + &["interfaces"], + &["term", "item", "intern"], + &["iterations"], + &["interpreter"], + &["interrupt"], + &["iteration"], + &["itself"], + &["items"], + &["initialise"], + &["initialised"], + &["initialises"], + &["initialising"], + &["initialize"], + &["initialized"], + &["initializes"], + &["initializing"], + &["interest"], + &["interface"], + &["interfaces"], + &["internal"], + &["intervals"], &["introduced"], + &["itself"], + &["itself"], + &["itself"], + &["itself"], + &["items"], + &["itself"], + &["itself"], + &["iteration"], + &["iterations"], ], - range: 5..=8, + range: 2..=10, }; static WORD_IS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_IS_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_IS_CHILDREN), value: None, }; -pub static WORD_IS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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")], + values: &[&["issue"]], + range: 1..=1, +}; + +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("almic"), - dictgen::InsensitiveStr::Ascii("almist"), - dictgen::InsensitiveStr::Ascii("almists"), - dictgen::InsensitiveStr::Ascii("alnders"), - dictgen::InsensitiveStr::Ascii("areli"), - dictgen::InsensitiveStr::Ascii("arelis"), - dictgen::InsensitiveStr::Ascii("definitely"), - dictgen::InsensitiveStr::Ascii("lamisist"), - dictgen::InsensitiveStr::Ascii("lamisists"), - dictgen::InsensitiveStr::Ascii("lamiskt"), - dictgen::InsensitiveStr::Ascii("lamistas"), - dictgen::InsensitiveStr::Ascii("lamisters"), - dictgen::InsensitiveStr::Ascii("lamistisk"), - dictgen::InsensitiveStr::Ascii("lamit"), - dictgen::InsensitiveStr::Ascii("lamits"), - dictgen::InsensitiveStr::Ascii("lamsit"), - dictgen::InsensitiveStr::Ascii("lamsits"), - dictgen::InsensitiveStr::Ascii("landes"), - dictgen::InsensitiveStr::Ascii("lmaic"), - dictgen::InsensitiveStr::Ascii("lmaists"), - dictgen::InsensitiveStr::Ascii("loate"), - dictgen::InsensitiveStr::Ascii("malist"), - dictgen::InsensitiveStr::Ascii("ntallation"), - dictgen::InsensitiveStr::Ascii("ntaller"), - dictgen::InsensitiveStr::Ascii("ntalling"), - dictgen::InsensitiveStr::Ascii("ntalls"), - dictgen::InsensitiveStr::Ascii("ntances"), - dictgen::InsensitiveStr::Ascii("ntantly"), - dictgen::InsensitiveStr::Ascii("ntructed"), - dictgen::InsensitiveStr::Ascii("ntrument"), - dictgen::InsensitiveStr::Ascii("ntrumental"), - dictgen::InsensitiveStr::Ascii("ntruments"), - dictgen::InsensitiveStr::Ascii("olatie"), - dictgen::InsensitiveStr::Ascii("raeliens"), - dictgen::InsensitiveStr::Ascii("raelies"), - dictgen::InsensitiveStr::Ascii("raelitas"), - dictgen::InsensitiveStr::Ascii("raelits"), - dictgen::InsensitiveStr::Ascii("raelli"), - dictgen::InsensitiveStr::Ascii("ralei"), - dictgen::InsensitiveStr::Ascii("raleis"), - dictgen::InsensitiveStr::Ascii("ralies"), - dictgen::InsensitiveStr::Ascii("reali"), - dictgen::InsensitiveStr::Ascii("realis"), - dictgen::InsensitiveStr::Ascii("sueing"), + dictgen::InsensitiveStr::Ascii("alling"), + 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"), ], values: &[ - &["islamic"], - &["islamist"], - &["islamists"], - &["islanders"], + &["installing"], + &["instance"], + &["instead"], + &["listened"], + &["listener"], + &["listeners"], + &["listening"], + &["its", "lists"], + ], + 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("sue"), + dictgen::InsensitiveStr::Ascii("sued"), + dictgen::InsensitiveStr::Ascii("sues"), + dictgen::InsensitiveStr::Ascii("ueing"), + ], + values: &[&["issue"], &["issued"], &["issues"], &["issuing"]], + range: 3..=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"], - &["indefinitely"], - &["islamist"], - &["islamists"], - &["islamist"], - &["islamists"], - &["islamists"], - &["islamists"], - &["islamist"], - &["islamist"], - &["islamist"], - &["islamists"], - &["islanders"], - &["islamic"], - &["islamists"], - &["isolate"], - &["islamist"], + &["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("lay")], + values: &[&["display"]], + range: 3..=3, +}; + +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("piron"), + dictgen::InsensitiveStr::Ascii("tallation"), + dictgen::InsensitiveStr::Ascii("tallations"), + 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("tructed"), + dictgen::InsensitiveStr::Ascii("trument"), + dictgen::InsensitiveStr::Ascii("trumental"), + dictgen::InsensitiveStr::Ascii("truments"), + ], + values: &[ + &["inspiron"], &["installation"], + &["installations"], &["installer"], &["installing"], &["installs"], + &["instance"], &["instances"], &["instantly"], &["instructed"], &["instrument"], &["instrumental"], &["instruments"], - &["isolate"], - &["israelis"], - &["israelis"], - &["israelis"], - &["israelis"], - &["israeli"], - &["israeli"], - &["israelis"], - &["israelis"], - &["israeli"], - &["israelis"], - &["issuing"], ], range: 5..=10, }; -static WORD_IR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_IR_CHILDREN), +static WORD_ISM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ISM_CHILDREN), value: None, }; -pub static WORD_IR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ISM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("anain"), - dictgen::InsensitiveStr::Ascii("anains"), - dictgen::InsensitiveStr::Ascii("anianos"), - dictgen::InsensitiveStr::Ascii("anias"), - dictgen::InsensitiveStr::Ascii("anina"), - dictgen::InsensitiveStr::Ascii("aninas"), + 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("lmic"), + dictgen::InsensitiveStr::Ascii("lmist"), + dictgen::InsensitiveStr::Ascii("lmists"), + dictgen::InsensitiveStr::Ascii("lnders"), + dictgen::InsensitiveStr::Ascii("reli"), + dictgen::InsensitiveStr::Ascii("relis"), + ], + values: &[ + &["islamic"], + &["islamist"], + &["islamists"], + &["islanders"], + &["israeli"], + &["israelis"], + ], + range: 4..=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("adation"), + 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("esistible"), - dictgen::InsensitiveStr::Ascii("esistibly"), - dictgen::InsensitiveStr::Ascii("itable"), - dictgen::InsensitiveStr::Ascii("itated"), - dictgen::InsensitiveStr::Ascii("leand"), - dictgen::InsensitiveStr::Ascii("onamn"), - dictgen::InsensitiveStr::Ascii("oncially"), - dictgen::InsensitiveStr::Ascii("onicaly"), - dictgen::InsensitiveStr::Ascii("onicly"), - dictgen::InsensitiveStr::Ascii("racional"), - dictgen::InsensitiveStr::Ascii("rationably"), - dictgen::InsensitiveStr::Ascii("rationallity"), - dictgen::InsensitiveStr::Ascii("rationallly"), - dictgen::InsensitiveStr::Ascii("rationaly"), - dictgen::InsensitiveStr::Ascii("rationatly"), - dictgen::InsensitiveStr::Ascii("rationel"), - dictgen::InsensitiveStr::Ascii("rationella"), - dictgen::InsensitiveStr::Ascii("rationnal"), - dictgen::InsensitiveStr::Ascii("relavant"), - dictgen::InsensitiveStr::Ascii("relavent"), - dictgen::InsensitiveStr::Ascii("relevent"), - dictgen::InsensitiveStr::Ascii("relivant"), - dictgen::InsensitiveStr::Ascii("relivent"), - dictgen::InsensitiveStr::Ascii("replacable"), - dictgen::InsensitiveStr::Ascii("resistable"), - dictgen::InsensitiveStr::Ascii("resistably"), - dictgen::InsensitiveStr::Ascii("respecitve"), - dictgen::InsensitiveStr::Ascii("responcible"), - dictgen::InsensitiveStr::Ascii("responisble"), - dictgen::InsensitiveStr::Ascii("responsable"), - dictgen::InsensitiveStr::Ascii("responsbile"), - dictgen::InsensitiveStr::Ascii("responsble"), - dictgen::InsensitiveStr::Ascii("responsibe"), - dictgen::InsensitiveStr::Ascii("responsibile"), - dictgen::InsensitiveStr::Ascii("revelant"), - dictgen::InsensitiveStr::Ascii("reverant"), - dictgen::InsensitiveStr::Ascii("reverisble"), - dictgen::InsensitiveStr::Ascii("reversebly"), - dictgen::InsensitiveStr::Ascii("reversiable"), - dictgen::InsensitiveStr::Ascii("reversibel"), - dictgen::InsensitiveStr::Ascii("reversibelt"), - dictgen::InsensitiveStr::Ascii("reversibile"), - dictgen::InsensitiveStr::Ascii("revirsible"), - dictgen::InsensitiveStr::Ascii("ridation"), - dictgen::InsensitiveStr::Ascii("riration"), - dictgen::InsensitiveStr::Ascii("rispective"), - dictgen::InsensitiveStr::Ascii("risponsible"), - dictgen::InsensitiveStr::Ascii("ritacion"), - dictgen::InsensitiveStr::Ascii("ritatie"), - dictgen::InsensitiveStr::Ascii("ritaties"), - dictgen::InsensitiveStr::Ascii("ritatin"), - dictgen::InsensitiveStr::Ascii("ritato"), - dictgen::InsensitiveStr::Ascii("riversible"), + 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"], + &["irradiation"], + &["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"], @@ -44318,64 +83347,8 @@ pub static WORD_IR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["iranians"], &["iranian"], &["iranians"], - &["irrelevant"], - &["irresistible"], - &["irresistibly"], - &["irresistible"], - &["irresistibly"], - &["irritable"], - &["irritated"], - &["ireland"], - &["ironman"], - &["ironically"], - &["ironically"], - &["ironically"], - &["irrational"], - &["irrationally"], - &["irrationally"], - &["irrationally"], - &["irrationally"], - &["irrationally"], - &["irrational"], - &["irrational"], - &["irrational"], - &["irrelevant"], - &["irrelevant"], - &["irrelevant"], - &["irrelevant"], - &["irrelevant"], - &["irreplaceable"], - &["irresistible"], - &["irresistibly"], - &["irrespective"], - &["irresponsible"], - &["irresponsible"], - &["irresponsible"], - &["irresponsible"], - &["irresponsible"], - &["irresponsible"], - &["irresponsible"], - &["irrelevant"], - &["irrelevant"], - &["irreversible"], - &["irreversible"], - &["irreversible"], - &["irreversible"], - &["irreversible"], - &["irreversible"], - &["irreversible"], - &["irritation"], - &["irritation"], - &["irrespective"], - &["irresponsible"], - &["irritation"], - &["irritate"], - &["irritate"], - &["irritation"], - &["irritation"], - &["irreversible"], ], - range: 5..=12, + range: 4..=6, }; static WORD_IP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44384,9 +83357,21 @@ static WORD_IP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_IP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ubrofen")], - values: &[&["ibuprofen"]], - range: 7..=7, + 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 { @@ -44395,9 +83380,21 @@ static WORD_IO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_IO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rnman")], - values: &[&["ironman"]], - range: 5..=5, + 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 { @@ -44510,7 +83507,16 @@ static WORD_INVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("lentary"), dictgen::InsensitiveStr::Ascii("lintary"), @@ -44530,7 +83536,16 @@ pub static WORD_INVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("vling"), ], values: &[ + &["invocation"], &["invoker"], + &["invocable"], + &["invocation"], + &["invocations"], + &["invoked", "invoke"], + &["invoke"], + &["invoked"], + &["invokes"], + &["invoking"], &["involuntary"], &["involuntary"], &["involuntary"], @@ -44559,6 +83574,9 @@ static WORD_INVL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -44566,13 +83584,16 @@ pub static WORD_INVL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("unerable"), ], values: &[ + &["invalid"], + &["invalid"], + &["invisible"], &["involve"], &["involved"], &["involves"], &["involving"], &["invulnerable"], ], - range: 3..=8, + range: 2..=8, }; static WORD_INVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44582,10 +83603,13 @@ static WORD_INVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("dual"), + dictgen::InsensitiveStr::Ascii("dually"), dictgen::InsensitiveStr::Ascii("ncable"), dictgen::InsensitiveStr::Ascii("nceble"), dictgen::InsensitiveStr::Ascii("ncibe"), @@ -44595,22 +83619,30 @@ pub static WORD_INVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("nicble"), dictgen::InsensitiveStr::Ascii("nsible"), dictgen::InsensitiveStr::Ascii("nvible"), + 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("tating"), dictgen::InsensitiveStr::Ascii("tato"), ], values: &[ + &["invitation"], &["invisibility"], &["invincible"], &["individual"], &["individually"], + &["individual"], + &["individually"], &["invincible"], &["invincible"], &["invincible"], @@ -44620,12 +83652,17 @@ pub static WORD_INVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["invincible"], &["invincible"], &["invincible"], + &["invisible"], + &["invisibility"], + &["invisible"], + &["invisibility"], + &["invisible"], &["invisibility"], &["invisibility"], &["invisibility"], &["invisibility"], &["invisibility"], - &["invisibility"], + &["invisible"], &["invisibility"], &["invitation"], &["invitation"], @@ -44635,140 +83672,237 @@ pub static WORD_INVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_INVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INVE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INVE_CHILDREN), value: None, }; -pub static WORD_INVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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")], + values: &[&["inverting"]], + 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("itable"), - dictgen::InsensitiveStr::Ascii("itably"), - dictgen::InsensitiveStr::Ascii("nsions"), - dictgen::InsensitiveStr::Ascii("ntario"), - dictgen::InsensitiveStr::Ascii("ntarlo"), - dictgen::InsensitiveStr::Ascii("ntaron"), - dictgen::InsensitiveStr::Ascii("nter"), - dictgen::InsensitiveStr::Ascii("ntings"), - dictgen::InsensitiveStr::Ascii("ntiones"), - dictgen::InsensitiveStr::Ascii("ntios"), - dictgen::InsensitiveStr::Ascii("ntivos"), - dictgen::InsensitiveStr::Ascii("rtendo"), - dictgen::InsensitiveStr::Ascii("rterad"), - dictgen::InsensitiveStr::Ascii("rtes"), - dictgen::InsensitiveStr::Ascii("rtibrates"), - dictgen::InsensitiveStr::Ascii("rtions"), - dictgen::InsensitiveStr::Ascii("rvention"), - dictgen::InsensitiveStr::Ascii("sitgate"), - dictgen::InsensitiveStr::Ascii("sitgation"), - dictgen::InsensitiveStr::Ascii("sitgations"), - dictgen::InsensitiveStr::Ascii("sitgative"), - dictgen::InsensitiveStr::Ascii("sitgators"), - dictgen::InsensitiveStr::Ascii("stagate"), - dictgen::InsensitiveStr::Ascii("stagated"), - dictgen::InsensitiveStr::Ascii("stagator"), - dictgen::InsensitiveStr::Ascii("stagators"), - dictgen::InsensitiveStr::Ascii("stegated"), - dictgen::InsensitiveStr::Ascii("stegating"), - dictgen::InsensitiveStr::Ascii("stegator"), - dictgen::InsensitiveStr::Ascii("stegators"), - dictgen::InsensitiveStr::Ascii("stemnt"), - dictgen::InsensitiveStr::Ascii("stiage"), - dictgen::InsensitiveStr::Ascii("stiagte"), - dictgen::InsensitiveStr::Ascii("stiagtion"), - dictgen::InsensitiveStr::Ascii("stiagtions"), - dictgen::InsensitiveStr::Ascii("stiagtive"), - dictgen::InsensitiveStr::Ascii("stigacion"), - dictgen::InsensitiveStr::Ascii("stigaiton"), - dictgen::InsensitiveStr::Ascii("stigare"), - dictgen::InsensitiveStr::Ascii("stigaron"), - dictgen::InsensitiveStr::Ascii("stigater"), - dictgen::InsensitiveStr::Ascii("stigaters"), - dictgen::InsensitiveStr::Ascii("stigatie"), - dictgen::InsensitiveStr::Ascii("stigatin"), - dictgen::InsensitiveStr::Ascii("stigatio"), - dictgen::InsensitiveStr::Ascii("stigationes"), - dictgen::InsensitiveStr::Ascii("stigatiors"), - dictgen::InsensitiveStr::Ascii("stigativo"), - dictgen::InsensitiveStr::Ascii("stigativos"), - dictgen::InsensitiveStr::Ascii("stigaton"), - dictgen::InsensitiveStr::Ascii("stigatons"), - dictgen::InsensitiveStr::Ascii("stige"), - dictgen::InsensitiveStr::Ascii("stigsting"), - dictgen::InsensitiveStr::Ascii("stigstion"), - dictgen::InsensitiveStr::Ascii("stigstions"), - dictgen::InsensitiveStr::Ascii("stingate"), - dictgen::InsensitiveStr::Ascii("stions"), - dictgen::InsensitiveStr::Ascii("stirat"), - dictgen::InsensitiveStr::Ascii("stmens"), - dictgen::InsensitiveStr::Ascii("stmet"), - dictgen::InsensitiveStr::Ascii("stogator"), - dictgen::InsensitiveStr::Ascii("stogators"), + 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("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: &[ - &["inevitable"], - &["inevitably"], - &["inventions"], - &["inventor"], - &["inventor"], - &["inventor"], - &["inventor"], - &["inventions"], - &["inventions"], - &["inventions"], + &["investigate"], + &["investigated"], + &["investigating"], + &["investigation"], + &["investigations"], + &["investigative"], + &["investigators"], + &["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: 4..=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("ded"), + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("ions"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("tendo"), + dictgen::InsensitiveStr::Ascii("terad"), + dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("tibrates"), + dictgen::InsensitiveStr::Ascii("tions"), + dictgen::InsensitiveStr::Ascii("val"), + dictgen::InsensitiveStr::Ascii("vention"), + dictgen::InsensitiveStr::Ascii("yed"), + ], + values: &[ + &["inverted"], + &["inversion"], + &["inversions"], + &["inverse", "invert"], &["inverted"], &["inverted"], &["inverse"], &["invertebrates"], &["inventions"], + &["interval"], &["intervention"], - &["investigate"], - &["investigation"], - &["investigations"], - &["investigative"], - &["investigators"], - &["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"], + &["inverted"], ], - range: 4..=11, + 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 { @@ -44780,8 +83914,15 @@ pub static WORD_INVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -44789,20 +83930,33 @@ pub static WORD_INVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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("ulable"), ], values: &[ &["invaders"], &["invaders"], + &["invalid"], + &["invalid"], &["invalidates"], + &["invalid"], &["invariably"], + &["invalid"], + &["invalid"], + &["invalidates"], + &["invalid"], &["invalidates"], &["invalidates"], &["invalidate"], @@ -44810,16 +83964,22 @@ pub static WORD_INVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["invalidate"], &["invalidate"], &["invalidates"], + &["invalidation"], + &["invalid"], + &["invalidate"], &["invaluable"], + &["invalid"], &["invaluable"], &["invariably"], &["invariably"], &["invariably"], &["invariably"], &["invariably"], + &["invariant"], + &["invariants"], &["invaluable"], ], - range: 5..=7, + range: 2..=9, }; static WORD_INU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44832,19 +83992,21 @@ pub static WORD_INU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["enumerable", "innumerable"], &["insurgency"], + &["input"], &["intuition"], &["intuitive"], &["intuitively"], ], - range: 5..=8, + range: 1..=8, }; static WORD_INT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44859,7 +84021,7 @@ static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_INTE_NODE), None, - None, + Some(&WORD_INTG_NODE), None, Some(&WORD_INTI_NODE), None, @@ -44868,11 +84030,11 @@ static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_INTO_NODE), - None, - None, + Some(&WORD_INTP_NODE), + Some(&WORD_INTQ_NODE), Some(&WORD_INTR_NODE), Some(&WORD_INTS_NODE), - None, + Some(&WORD_INTT_NODE), Some(&WORD_INTU_NODE), None, None, @@ -44888,6 +84050,7 @@ static WORD_INTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -44896,11 +84059,15 @@ pub static WORD_INTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -44909,11 +84076,25 @@ pub static WORD_INTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["intuitively"], &["intuition"], &["intuitively"], + &["interpretation"], + &["interpretation"], + &["interpret"], &["interrupting"], &["intuitive"], &["intuitively"], ], - range: 4..=8, + 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")], + values: &[&["interrupt"]], + range: 6..=6, }; static WORD_INTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44922,9 +84103,12 @@ static WORD_INTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_INTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rumental")], - values: &[&["instrumental"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("rumental"), + dictgen::InsensitiveStr::Ascii("tead"), + ], + values: &[&["instrumental"], &["instead"]], + range: 4..=8, }; static WORD_INTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -44950,7 +84134,7 @@ static WORD_INTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_INTRO_NODE), None, None, - None, + Some(&WORD_INTRR_NODE), None, None, Some(&WORD_INTRU_NODE), @@ -44968,6 +84152,8 @@ static WORD_INTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ction"), + dictgen::InsensitiveStr::Ascii("ctions"), dictgen::InsensitiveStr::Ascii("duced"), dictgen::InsensitiveStr::Ascii("duces"), dictgen::InsensitiveStr::Ascii("ducing"), @@ -44978,9 +84164,13 @@ pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], + &["instructions"], &["introduced"], &["introduces"], &["introducing"], @@ -44991,11 +84181,34 @@ pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["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, @@ -45022,6 +84235,10 @@ pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -45057,8 +84274,12 @@ pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["introduced"], &["introduction"], &["introduces"], + &["introduces", "introduce"], + &["introduces", "introduced"], &["introduces"], - &["introduces"], + &["introducing"], + &["introspectable"], + &["introspection"], &["introspection"], &["introspection"], &["introspection"], @@ -45076,7 +84297,7 @@ pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["introvert"], &["introverted"], ], - range: 3..=8, + range: 3..=10, }; static WORD_INTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45089,6 +84310,9 @@ pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -45103,6 +84327,7 @@ pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -45113,6 +84338,9 @@ pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["intricacies"], &["intricacies"], &["intricacies"], + &["introduce"], + &["introduced"], + &["introduction"], &["intrigue"], &["intriguing"], &["intrigue"], @@ -45127,6 +84355,7 @@ pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["intriguing"], &["intrinsic"], &["intrinsically"], + &["intrinsics"], &["intrinsic"], &["intrinsically"], &["intrigue"], @@ -45144,8 +84373,15 @@ static WORD_INTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -45155,15 +84391,28 @@ pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -45174,8 +84423,14 @@ pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["interpreter"], &["interpreting"], &["interrupt"], + &["interrupt"], &["interrupted"], &["interest"], + &["interested"], + &["interesting"], + &["interest", "insert"], + &["interested"], + &["interesting"], &["interwebs"], ], range: 2..=10, @@ -45203,6 +84458,8 @@ pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), ], @@ -45211,12 +84468,52 @@ pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["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", "inquire"], + &["inquired", "inquired"], + &["inquires", "inquires"], + &["inquiries", "inquiries"], + &["inquiry", "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, @@ -45245,6 +84542,7 @@ pub static WORD_INTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("rvert"), dictgen::InsensitiveStr::Ascii("rverted"), dictgen::InsensitiveStr::Ascii("rverts"), + dictgen::InsensitiveStr::Ascii("t"), dictgen::InsensitiveStr::Ascii("xicacion"), dictgen::InsensitiveStr::Ascii("xicatin"), dictgen::InsensitiveStr::Ascii("xicaton"), @@ -45275,6 +84573,7 @@ pub static WORD_INTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["introvert"], &["introverted"], &["introverts"], + &["into"], &["intoxication"], &["intoxication"], &["intoxication"], @@ -45283,104 +84582,351 @@ pub static WORD_INTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["intoxication"], &["intoxicated"], ], - range: 5..=8, + range: 1..=8, }; static WORD_INTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INTI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INTI_CHILDREN), value: None, }; -pub static WORD_INTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("al"), - dictgen::InsensitiveStr::Ascii("ally"), - dictgen::InsensitiveStr::Ascii("cracies"), - dictgen::InsensitiveStr::Ascii("crate"), - dictgen::InsensitiveStr::Ascii("dimate"), - dictgen::InsensitiveStr::Ascii("dimation"), + 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("llectual"), - dictgen::InsensitiveStr::Ascii("llectually"), - dictgen::InsensitiveStr::Ascii("llectuals"), - dictgen::InsensitiveStr::Ascii("madate"), - dictgen::InsensitiveStr::Ascii("madated"), - dictgen::InsensitiveStr::Ascii("matley"), - dictgen::InsensitiveStr::Ascii("maty"), - dictgen::InsensitiveStr::Ascii("miated"), - dictgen::InsensitiveStr::Ascii("midacion"), - dictgen::InsensitiveStr::Ascii("midad"), - dictgen::InsensitiveStr::Ascii("midade"), - dictgen::InsensitiveStr::Ascii("midades"), - dictgen::InsensitiveStr::Ascii("midant"), - dictgen::InsensitiveStr::Ascii("midante"), - dictgen::InsensitiveStr::Ascii("midare"), - dictgen::InsensitiveStr::Ascii("midatie"), - dictgen::InsensitiveStr::Ascii("midatin"), - dictgen::InsensitiveStr::Ascii("midative"), - dictgen::InsensitiveStr::Ascii("midaton"), - dictgen::InsensitiveStr::Ascii("mide"), - dictgen::InsensitiveStr::Ascii("midiate"), - dictgen::InsensitiveStr::Ascii("minated"), - dictgen::InsensitiveStr::Ascii("mitade"), - dictgen::InsensitiveStr::Ascii("mitaded"), - dictgen::InsensitiveStr::Ascii("mitading"), - dictgen::InsensitiveStr::Ascii("mitaly"), - dictgen::InsensitiveStr::Ascii("mitate"), - dictgen::InsensitiveStr::Ascii("mitated"), - dictgen::InsensitiveStr::Ascii("mitating"), - dictgen::InsensitiveStr::Ascii("mitation"), - dictgen::InsensitiveStr::Ascii("mitely"), - dictgen::InsensitiveStr::Ascii("rcate"), - dictgen::InsensitiveStr::Ascii("ution"), - dictgen::InsensitiveStr::Ascii("utive"), - dictgen::InsensitiveStr::Ascii("utively"), + dictgen::InsensitiveStr::Ascii("y"), ], values: &[ &["initial"], - &["initially"], - &["intricacies"], - &["intricate"], - &["intimidate"], - &["intimidation"], + &["initialization"], + &["initialize"], + &["initialized"], &["initials"], - &["intellectual"], - &["intellectually"], - &["intellectuals"], - &["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"], - &["intimately"], - &["intricate"], - &["intuition"], - &["intuitive"], - &["intuitively"], + &["entity"], ], - range: 2..=10, + 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("lectual"), + dictgen::InsensitiveStr::Ascii("lectually"), + dictgen::InsensitiveStr::Ascii("lectuals"), + ], + values: &[&["intellectual"], &["intellectually"], &["intellectuals"]], + range: 7..=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_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("ilises"), + dictgen::InsensitiveStr::Ascii("ilize"), + dictgen::InsensitiveStr::Ascii("ilized"), + 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("lization"), + 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"], + &["initialises"], + &["initialize"], + &["initialized"], + &["initializes"], + &["initializing"], + &["initial"], + &["initial"], + &["initialisation"], + &["initialise"], + &["initialised"], + &["initialiser"], + &["initialisers"], + &["initialises"], + &["initialising"], + &["initialisation"], + &["initialization"], + &["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("ers")], + values: &[&["integers"]], + range: 3..=3, }; static WORD_INTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45389,10 +84935,10 @@ static WORD_INTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_INTEA_NODE), None, None, - None, - None, + Some(&WORD_INTED_NODE), None, Some(&WORD_INTEF_NODE), Some(&WORD_INTEG_NODE), @@ -45401,7 +84947,7 @@ static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_INTEL_NODE), - None, + Some(&WORD_INTEM_NODE), Some(&WORD_INTEN_NODE), None, Some(&WORD_INTEP_NODE), @@ -45423,9 +84969,13 @@ static WORD_INTEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_INTEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ene")], - values: &[&["intervene"]], - range: 3..=3, + 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 { @@ -45435,6 +84985,7 @@ static WORD_INTES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_INTES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ity"), dictgen::InsensitiveStr::Ascii("nely"), dictgen::InsensitiveStr::Ascii("nity"), dictgen::InsensitiveStr::Ascii("tents"), @@ -45445,6 +84996,7 @@ pub static WORD_INTES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("tions"), ], values: &[ + &["intensity"], &["intensely"], &["intensity"], &["intestines"], @@ -45454,7 +85006,7 @@ pub static WORD_INTES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["intestines"], &["intestines"], ], - range: 4..=6, + range: 3..=6, }; static WORD_INTER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45477,7 +85029,7 @@ static WORD_INTER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st Some(&WORD_INTERL_NODE), Some(&WORD_INTERM_NODE), Some(&WORD_INTERN_NODE), - None, + Some(&WORD_INTERO_NODE), Some(&WORD_INTERP_NODE), None, Some(&WORD_INTERR_NODE), @@ -45513,11 +85065,13 @@ static WORD_INTERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -45551,6 +85105,7 @@ pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("iwer"), ], values: &[ + &["interval"], &["intervals"], &["intervals"], &["intervals"], @@ -45558,6 +85113,7 @@ pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["intervene"], &["intervening"], &["intervening"], + &["intervening"], &["interviewed"], &["interviewer"], &["interviewing"], @@ -45597,9 +85153,21 @@ static WORD_INTERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_INTERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("pt")], - values: &[&["interrupt"]], - range: 2..=2, + 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 { @@ -45612,6 +85180,8 @@ pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -45621,12 +85191,14 @@ pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["intertwined"], &["entertaining"], &["entertainment"], + &["inertia"], + &["inertial"], &["intertwined"], &["intertwined"], &["intertwined"], &["intertwined"], ], - range: 5..=7, + range: 2..=7, }; static WORD_INTERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45636,40 +85208,58 @@ static WORD_INTERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_INTERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cetion"), dictgen::InsensitiveStr::Ascii("eccion"), 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"], - &["intersections"], + &["intersection"], &["intersections"], &["intersection"], + &["intersections"], + &["intersection"], + &["intersections"], &["interception"], + &["intercepts", "intersteps"], &["interstellar"], + &["interspersed"], + &["interest"], &["interstate"], &["interstellar"], &["interstellar"], &["interstate"], + &["interested"], &["interstellar"], &["interstellar"], &["interstellar"], &["interstellar"], &["interstellar"], + &["interesting"], + &["interests"], ], - range: 2..=9, + range: 1..=9, }; static WORD_INTERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45680,146 +85270,342 @@ static WORD_INTERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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::Flat(&WORD_INTERP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INTERP_CHILDREN), value: None, }; -pub static WORD_INTERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("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"], + &["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("layed"), + dictgen::InsensitiveStr::Ascii("rated"), + ], + values: &[ + &["interpolated"], + &["interpolation"], + &["interpolation"], + &["interpolator"], + &["interpolated"], + &["interpolated", "interpreted"], + ], + range: 3..=6, + }; + +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("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"], + &["interpreting"], + &["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("ersonel"), - dictgen::InsensitiveStr::Ascii("ersonnal"), - dictgen::InsensitiveStr::Ascii("ert"), - dictgen::InsensitiveStr::Ascii("ertation"), - dictgen::InsensitiveStr::Ascii("ertations"), - dictgen::InsensitiveStr::Ascii("erted"), - dictgen::InsensitiveStr::Ascii("erter"), - dictgen::InsensitiveStr::Ascii("erters"), - dictgen::InsensitiveStr::Ascii("erting"), - dictgen::InsensitiveStr::Ascii("et"), - dictgen::InsensitiveStr::Ascii("ratation"), - dictgen::InsensitiveStr::Ascii("ratations"), - dictgen::InsensitiveStr::Ascii("rate"), - dictgen::InsensitiveStr::Ascii("rating"), - dictgen::InsensitiveStr::Ascii("rered"), - dictgen::InsensitiveStr::Ascii("resonal"), - dictgen::InsensitiveStr::Ascii("retacion"), - dictgen::InsensitiveStr::Ascii("retaciones"), - dictgen::InsensitiveStr::Ascii("retaion"), - dictgen::InsensitiveStr::Ascii("retaiton"), - dictgen::InsensitiveStr::Ascii("retare"), - dictgen::InsensitiveStr::Ascii("retarea"), - dictgen::InsensitiveStr::Ascii("retarem"), - dictgen::InsensitiveStr::Ascii("retares"), - dictgen::InsensitiveStr::Ascii("retarse"), - dictgen::InsensitiveStr::Ascii("retarte"), - dictgen::InsensitiveStr::Ascii("retatin"), - dictgen::InsensitiveStr::Ascii("retating"), - dictgen::InsensitiveStr::Ascii("retationen"), - dictgen::InsensitiveStr::Ascii("retato"), - dictgen::InsensitiveStr::Ascii("reteer"), - dictgen::InsensitiveStr::Ascii("reteert"), - dictgen::InsensitiveStr::Ascii("retier"), - dictgen::InsensitiveStr::Ascii("retion"), - dictgen::InsensitiveStr::Ascii("retter"), - dictgen::InsensitiveStr::Ascii("ritation"), - dictgen::InsensitiveStr::Ascii("ritations"), - dictgen::InsensitiveStr::Ascii("riting"), - dictgen::InsensitiveStr::Ascii("rut"), + dictgen::InsensitiveStr::Ascii("gators"), + dictgen::InsensitiveStr::Ascii("peable"), + dictgen::InsensitiveStr::Ascii("prability"), ], values: &[ - &["interpersonal"], - &["interpersonal"], - &["interpret"], - &["interpretation"], - &["interpretations"], - &["interpreted"], - &["interpreter"], - &["interpreter"], - &["interpreting"], - &["interpret"], - &["interpretation"], - &["interpretations"], - &["interpret"], - &["interpreting"], - &["interpreter"], - &["interpersonal"], - &["interpretation"], - &["interpretations"], - &["interpretation"], - &["interpretations"], - &["interpreter"], - &["interpreter"], - &["interpreter"], - &["interpreter"], - &["interpreter"], - &["interpreter"], - &["interpretations"], - &["interpretation"], - &["interpretations"], - &["interpretation"], - &["interpreter"], - &["interpreter"], - &["interpreter"], - &["interpreting"], - &["interpreter"], - &["interpretation"], - &["interpretations"], - &["interpreting"], - &["interrupt"], + &["interrogators"], + &["interoperable"], + &["interoperability"], ], - range: 2..=10, + range: 6..=9, }; static WORD_INTERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45830,7 +85616,10 @@ static WORD_INTERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("atioanl"), dictgen::InsensitiveStr::Ascii("ation"), dictgen::InsensitiveStr::Ascii("ationaal"), dictgen::InsensitiveStr::Ascii("ationaly"), @@ -45839,7 +85628,9 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -45852,12 +85643,16 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], &["international"], &["international"], @@ -45868,7 +85663,9 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["internationally"], &["interactions"], &["intermediate"], + &["internal"], &["internalized"], + &["internals"], &["internets"], &["internets"], &["internets"], @@ -45881,6 +85678,7 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["internets"], &["internets"], &["internets"], + &["interface"], &["internalized"], &["internet"], &["interns"], @@ -45891,7 +85689,7 @@ pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d static WORD_INTERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_INTERM_CHILDREN), - value: Some(&["interim"]), + value: Some(&["interim", "intern"]), }; pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -45901,12 +85699,15 @@ pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("itent"), + dictgen::InsensitiveStr::Ascii("ittant"), dictgen::InsensitiveStr::Ascii("ittient"), dictgen::InsensitiveStr::Ascii("ittment"), + dictgen::InsensitiveStr::Ascii("perance"), ], values: &[ &["intermediate"], @@ -45914,12 +85715,15 @@ pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["intermediate"], &["intermediate"], &["intermediate"], + &["intermediate"], &["intermittent"], &["intermediate"], &["intermediate"], &["intermittent"], &["intermittent"], &["intermittent"], + &["intermittent"], + &["intemperance"], ], range: 4..=7, }; @@ -45934,9 +85738,17 @@ pub static WORD_INTERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("ectual"), dictgen::InsensitiveStr::Ascii("ectually"), dictgen::InsensitiveStr::Ascii("ectuals"), + dictgen::InsensitiveStr::Ascii("iveing"), + dictgen::InsensitiveStr::Ascii("ly"), ], - values: &[&["intellectual"], &["intellectually"], &["intellectuals"]], - range: 6..=8, + values: &[ + &["intellectual"], + &["intellectually"], + &["intellectuals"], + &["interleaving"], + &["internally"], + ], + range: 2..=8, }; static WORD_INTERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45949,9 +85761,23 @@ pub static WORD_INTERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"]], - range: 3..=4, + values: &[ + &["interior"], + &["interior"], + &["interior"], + &["inherit"], + &["inheritance"], + &["inherited"], + &["inheriting"], + &["inherits"], + ], + range: 1..=5, }; static WORD_INTERG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -45965,8 +85791,12 @@ pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("rated"), + dictgen::InsensitiveStr::Ascii("rating"), dictgen::InsensitiveStr::Ascii("ration"), ], values: &[ @@ -45974,8 +85804,12 @@ pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["integrate"], &["integrated"], &["integration"], + &["integer"], + &["integrated"], + &["integers"], &["integrity"], &["integrated"], + &["integrating"], &["integration"], ], range: 2..=6, @@ -45989,8 +85823,17 @@ static WORD_INTERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("acce"), + 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"), @@ -46011,8 +85854,17 @@ pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d ], values: &[ &["interfaces"], + &["interval"], + &["intervals"], &["interfaces"], &["interface"], + &["interfaces"], + &["interface"], + &["interfaces"], + &["interface"], + &["interfere"], + &["interference"], + &["interference"], &["interferes"], &["interfere"], &["interferes"], @@ -46026,12 +85878,12 @@ pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["interferes"], &["interference"], &["interfere"], - &["interfere"], + &["interfere", "interfered"], &["interferes"], &["interfering"], &["interferes"], ], - range: 2..=6, + range: 2..=7, }; static WORD_INTERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46044,16 +85896,28 @@ pub static WORD_INTERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("action"), dictgen::InsensitiveStr::Ascii("actions"), dictgen::InsensitiveStr::Ascii("acts"), + dictgen::InsensitiveStr::Ascii("cptor"), dictgen::InsensitiveStr::Ascii("ct"), dictgen::InsensitiveStr::Ascii("cted"), dictgen::InsensitiveStr::Ascii("cting"), dictgen::InsensitiveStr::Ascii("ction"), dictgen::InsensitiveStr::Ascii("ctions"), dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("ested"), + dictgen::InsensitiveStr::Ascii("ference"), + dictgen::InsensitiveStr::Ascii("ferences"), dictgen::InsensitiveStr::Ascii("fers"), dictgen::InsensitiveStr::Ascii("lated"), + dictgen::InsensitiveStr::Ascii("laved"), dictgen::InsensitiveStr::Ascii("nt"), dictgen::InsensitiveStr::Ascii("nts"), + dictgen::InsensitiveStr::Ascii("pret"), + dictgen::InsensitiveStr::Ascii("pretation"), + dictgen::InsensitiveStr::Ascii("pretations"), + dictgen::InsensitiveStr::Ascii("preted"), + dictgen::InsensitiveStr::Ascii("preting"), + dictgen::InsensitiveStr::Ascii("prets"), + dictgen::InsensitiveStr::Ascii("pt"), dictgen::InsensitiveStr::Ascii("rsted"), dictgen::InsensitiveStr::Ascii("rsting"), dictgen::InsensitiveStr::Ascii("sant"), @@ -46061,30 +85925,55 @@ pub static WORD_INTERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("sction"), dictgen::InsensitiveStr::Ascii("sctions"), dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("sect"), + dictgen::InsensitiveStr::Ascii("sected"), + dictgen::InsensitiveStr::Ascii("secting"), + dictgen::InsensitiveStr::Ascii("section"), + dictgen::InsensitiveStr::Ascii("sections"), + dictgen::InsensitiveStr::Ascii("sects"), + dictgen::InsensitiveStr::Ascii("set"), + dictgen::InsensitiveStr::Ascii("seted"), + dictgen::InsensitiveStr::Ascii("seting"), dictgen::InsensitiveStr::Ascii("sing"), + dictgen::InsensitiveStr::Ascii("spersed"), dictgen::InsensitiveStr::Ascii("sring"), + dictgen::InsensitiveStr::Ascii("sseted"), dictgen::InsensitiveStr::Ascii("sst"), dictgen::InsensitiveStr::Ascii("ssted"), + dictgen::InsensitiveStr::Ascii("ssting"), dictgen::InsensitiveStr::Ascii("stes"), dictgen::InsensitiveStr::Ascii("stigly"), dictgen::InsensitiveStr::Ascii("stinly"), dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("view"), dictgen::InsensitiveStr::Ascii("wbs"), ], values: &[ &["intersection"], &["intersections"], &["interfaces"], + &["interceptor"], &["interacted"], &["interacted"], &["interacting"], &["interaction"], &["interactions"], - &["interred"], + &["interred", "interned"], + &["interested"], + &["interference"], + &["interferences"], &["interferes"], &["interrelated"], + &["interleaved"], &["internet"], &["internets"], + &["interpret"], + &["interpretation"], + &["interpretations"], + &["interpreted"], + &["interpreting"], + &["interprets"], + &["intercept"], &["interpreted"], &["interpreting"], &["interest"], @@ -46092,17 +85981,30 @@ pub static WORD_INTERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["intersection"], &["intersections"], &["interested"], - &["interesting"], - &["interfering"], - &["interests"], + &["intersect"], + &["intersected"], + &["intersecting"], + &["intersection"], + &["intersections"], + &["intersects"], + &["interest"], &["interested"], + &["interesting"], + &["interesting"], + &["interspersed"], + &["interfering"], + &["interested"], + &["interests", "interest"], + &["interested"], + &["interesting"], &["interests"], &["interestingly"], &["interestingly"], &["interest"], + &["interview"], &["interwebs"], ], - range: 1..=7, + range: 1..=10, }; static WORD_INTERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46112,6 +86014,8 @@ static WORD_INTERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -46119,6 +86023,7 @@ pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -46129,6 +86034,7 @@ pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -46136,13 +86042,16 @@ pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("ouse"), ], values: &[ - &["integration"], + &["interchange"], + &["interchanged"], + &["integration", "interaction"], &["interception"], &["interception"], &["interceptions"], &["interception"], &["interception"], &["interceptions"], + &["interchange"], &["interchangeable"], &["interchangeably"], &["interchangeably"], @@ -46153,6 +86062,7 @@ pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["interchangeable"], &["interchangeably"], &["intercourse"], + &["intercollegiate"], &["intercontinental"], &["intercontinental"], &["intercourse"], @@ -46169,7 +86079,7 @@ static WORD_INTERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_INTERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[dictgen::InsensitiveStr::Ascii("read")], - values: &[&["interbreed"]], + values: &[&["interbreed", "interbred"]], range: 4..=4, }; @@ -46182,8 +86092,12 @@ pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("ctice"), @@ -46191,22 +86105,52 @@ pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("tions"), + dictgen::InsensitiveStr::Ascii("tive"), + dictgen::InsensitiveStr::Ascii("tively"), + dictgen::InsensitiveStr::Ascii("tor"), + dictgen::InsensitiveStr::Ascii("tors"), ], values: &[ &["interaction"], - &["interacted"], + &["interacted", "interface"], + &["interfaces"], &["interactive"], + &["interactively"], &["interacts"], + &["interaction"], + &["interactions"], &["interactive"], &["interacts"], &["interactive"], @@ -46214,18 +86158,44 @@ pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["interacts"], &["interacts"], &["interacts"], - &["interacts"], &["interaction"], + &["interactions"], &["interacts"], - &["interacted"], - &["interaction"], &["interactive"], + &["interactively"], + &["interaction"], + &["interacts"], + &["interactive"], + &["interacted"], + &["interface"], + &["interact"], + &["interaction"], + &["interactions"], + &["interactive", "interactively"], + &["interactively"], + &["interactively"], + &["internal", "interval", "integral"], + &["internally"], + &["internals", "intervals", "integrals"], + &["internally"], + &["internal"], + &["internally"], &["interacted"], &["interacting"], + &["iterate"], + &["iterated", "interacted"], &["interstellar"], + &["iterates", "interacts"], + &["iterating", "interacting"], + &["iteration", "interaction"], &["international"], + &["iterations", "interactions"], + &["interactive"], + &["interactively"], + &["iterator"], + &["iterators"], ], - range: 2..=6, + range: 1..=7, }; static WORD_INTEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46235,11 +86205,44 @@ static WORD_INTEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["interpretation"], &["interpretor"]], - range: 7..=8, + 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 { @@ -46252,16 +86255,28 @@ pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ational"), 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("sion"), + dictgen::InsensitiveStr::Ascii("sional"), + dictgen::InsensitiveStr::Ascii("sionally"), + 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"), ], @@ -46269,20 +86284,43 @@ pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["international"], &["intentional"], &["intends"], - &["intends"], - &["intensity"], - &["intensely"], - &["intensity"], - &["intensely"], - &["intents"], - &["intents"], &["intended"], + &["intends"], + &["intended"], + &["intensity"], + &["intensely"], + &["intention"], + &["intentional"], + &["intentionally"], + &["intentionally"], + &["insensitive", "intensive"], + &["intensity"], + &["intensely"], + &["intents"], + &["intents"], + &["indentation"], + &["intended", "indented"], + &["intended"], + &["intentionally"], + &["intentionally"], &["intentional"], &["intestines"], + &["intentionally"], &["intentional"], &["intentional"], ], - range: 2..=7, + range: 2..=8, +}; + +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 { @@ -46293,10 +86331,18 @@ static WORD_INTEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -46313,6 +86359,7 @@ pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -46323,10 +86370,18 @@ pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di ], values: &[ &["intellectual"], - &["intellectuals"], - &["intellectuals"], &["intelligence"], &["intelligent"], + &["intelligently"], + &["intellectuals"], + &["intellectuals"], + &["intelligibility"], + &["intelligible"], + &["intelligence"], + &["intelligently"], + &["intelligence"], + &["intelligent"], + &["intellisense"], &["intellectuals"], &["intellectuals"], &["intellectuals"], @@ -46343,6 +86398,7 @@ pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["intellectuals"], &["intelligent"], &["intelligently"], + &["intelligible"], &["intelligence"], &["intelligent"], &["intelligently"], @@ -46361,6 +86417,11 @@ static WORD_INTEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("eral"), + dictgen::InsensitiveStr::Ascii("ere"), dictgen::InsensitiveStr::Ascii("irty"), dictgen::InsensitiveStr::Ascii("raal"), dictgen::InsensitiveStr::Ascii("racion"), @@ -46371,11 +86432,19 @@ pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ratie"), 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"], + &["integral"], + &["integer"], &["integrity"], &["integral"], &["integration"], @@ -46386,11 +86455,14 @@ pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["integrated"], &["integration"], &["integration"], + &["integrated"], &["interferes"], &["interfering"], &["integrated"], + &["integrity"], + &["integrity"], ], - range: 4..=6, + range: 3..=6, }; static WORD_INTEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46399,9 +86471,40 @@ static WORD_INTEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_INTEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("erring")], - values: &[&["interfering"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("ace"), + dictgen::InsensitiveStr::Ascii("erring"), + ], + values: &[&["interface"], &["interfering"]], + 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 { @@ -46411,28 +86514,42 @@ static WORD_INTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"], &["intimacy"], &["intimate"], + &["instance", "intense"], + &["instances"], &["intangible"], &["intangible"], &["intangible"], &["intangible"], &["intangible"], &["intangible"], + &["instantiate"], + &["instantiating"], &["intoxication"], ], - range: 4..=8, + range: 2..=8, }; static WORD_INS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46444,7 +86561,7 @@ static WORD_INS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_INSA_NODE), None, Some(&WORD_INSC_NODE), - None, + Some(&WORD_INSD_NODE), Some(&WORD_INSE_NODE), None, None, @@ -46479,14 +86596,17 @@ pub static WORD_INSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("alted"), dictgen::InsensitiveStr::Ascii("bstantiated"), dictgen::InsensitiveStr::Ascii("ccessful"), + dictgen::InsensitiveStr::Ascii("e"), dictgen::InsensitiveStr::Ascii("fficent"), dictgen::InsensitiveStr::Ascii("fficiant"), + dictgen::InsensitiveStr::Ascii("ffiency"), dictgen::InsensitiveStr::Ascii("ffucient"), 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"), @@ -46499,8 +86619,10 @@ pub static WORD_INSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["insulated"], &["unsubstantiated"], &["unsuccessful"], + &["ensue", "insure"], &["insufficient"], &["insufficient"], + &["insufficiency"], &["insufficient"], &["insinuating"], &["insults"], @@ -46508,6 +86630,7 @@ pub static WORD_INSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["insults"], &["insinuating"], &["insurance"], + &["insurance"], &["insurgency"], &["insurgency"], &["insurgency"], @@ -46515,7 +86638,7 @@ pub static WORD_INSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["unsuspecting"], &["unsustainable"], ], - range: 4..=11, + range: 1..=11, }; static WORD_INST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46537,12 +86660,12 @@ static WORD_INST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_INSTN_NODE), None, None, None, Some(&WORD_INSTR_NODE), - None, + Some(&WORD_INSTS_NODE), None, Some(&WORD_INSTU_NODE), None, @@ -46603,6 +86726,17 @@ pub static WORD_INSTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("allation")], + values: &[&["installation"]], + range: 8..=8, +}; + static WORD_INSTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_INSTR_CHILDREN), value: None, @@ -46610,12 +86744,23 @@ static WORD_INSTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_INSTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ace"), + dictgen::InsensitiveStr::Ascii("alled"), dictgen::InsensitiveStr::Ascii("ament"), dictgen::InsensitiveStr::Ascii("amental"), dictgen::InsensitiveStr::Ascii("aments"), + dictgen::InsensitiveStr::Ascii("ction"), + dictgen::InsensitiveStr::Ascii("cut"), + dictgen::InsensitiveStr::Ascii("cutino"), + dictgen::InsensitiveStr::Ascii("cutinos"), + dictgen::InsensitiveStr::Ascii("cution"), dictgen::InsensitiveStr::Ascii("cutions"), dictgen::InsensitiveStr::Ascii("cutor"), + dictgen::InsensitiveStr::Ascii("cuts"), + dictgen::InsensitiveStr::Ascii("ead"), + dictgen::InsensitiveStr::Ascii("insic"), dictgen::InsensitiveStr::Ascii("uccion"), + dictgen::InsensitiveStr::Ascii("uccions"), dictgen::InsensitiveStr::Ascii("ucion"), dictgen::InsensitiveStr::Ascii("uciton"), dictgen::InsensitiveStr::Ascii("ucitons"), @@ -46631,20 +86776,36 @@ pub static WORD_INSTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("umentos"), dictgen::InsensitiveStr::Ascii("umentul"), dictgen::InsensitiveStr::Ascii("umetal"), ], values: &[ + &["instance"], + &["installed"], &["instrument"], &["instrumental"], &["instruments"], &["instruction"], + &["instruct"], + &["instruction"], + &["instructions"], + &["instruction"], + &["instruction", "instructions"], &["instructors"], + &["instructs"], + &["instead"], + &["intrinsic"], + &["instruction"], + &["instructions"], &["instruction"], &["instruction"], - &["instruction"], - &["instruction"], + &["instruction", "instructions"], &["instructor"], &["instructors"], &["instructed"], @@ -46657,11 +86818,59 @@ pub static WORD_INSTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["instruction"], &["instructor"], &["instrumental"], + &["instrument"], + &["instrumentation"], + &["instrumented"], + &["instrumented"], + &["instrumentation"], &["instruments"], &["instrumental"], &["instrumental"], ], - range: 5..=7, + 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_INSTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46742,81 +86951,142 @@ static WORD_INSTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_INSTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("rt"), + dictgen::InsensitiveStr::Ascii("rted"), + dictgen::InsensitiveStr::Ascii("rtion"), ], - values: &[&["installing"], &["inserted"], &["inserting"]], - range: 3..=5, + values: &[ + &["instance"], + &["instead"], + &["instead"], + &["installing"], + &["insert"], + &["instead"], + &["inserted"], + &["inserting"], + &["interrupts"], + &["intersection"], + &["insert"], + &["inserted"], + &["insertion"], + ], + range: 1..=7, }; static WORD_INSTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INSTA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INSTA_CHILDREN), value: None, }; -pub static WORD_INSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_INSTA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + 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("biliy"), - dictgen::InsensitiveStr::Ascii("billity"), - dictgen::InsensitiveStr::Ascii("bilt"), - dictgen::InsensitiveStr::Ascii("bilty"), - dictgen::InsensitiveStr::Ascii("de"), - dictgen::InsensitiveStr::Ascii("laltion"), - dictgen::InsensitiveStr::Ascii("lation"), - dictgen::InsensitiveStr::Ascii("lement"), - dictgen::InsensitiveStr::Ascii("llatin"), - dictgen::InsensitiveStr::Ascii("llatons"), - dictgen::InsensitiveStr::Ascii("llatron"), - dictgen::InsensitiveStr::Ascii("lleer"), - dictgen::InsensitiveStr::Ascii("lleert"), - dictgen::InsensitiveStr::Ascii("llemnt"), - dictgen::InsensitiveStr::Ascii("llent"), - dictgen::InsensitiveStr::Ascii("lles"), - dictgen::InsensitiveStr::Ascii("llesd"), - dictgen::InsensitiveStr::Ascii("llion"), - dictgen::InsensitiveStr::Ascii("llling"), - dictgen::InsensitiveStr::Ascii("llmant"), - dictgen::InsensitiveStr::Ascii("llus"), - dictgen::InsensitiveStr::Ascii("nciate"), - dictgen::InsensitiveStr::Ascii("nse"), - dictgen::InsensitiveStr::Ascii("ntaenous"), - dictgen::InsensitiveStr::Ascii("ntaneos"), - dictgen::InsensitiveStr::Ascii("ntaneoulsy"), - dictgen::InsensitiveStr::Ascii("ntaneu"), - dictgen::InsensitiveStr::Ascii("ntaneus"), - dictgen::InsensitiveStr::Ascii("ntanious"), - dictgen::InsensitiveStr::Ascii("ntanous"), - dictgen::InsensitiveStr::Ascii("nteneous"), - dictgen::InsensitiveStr::Ascii("ntenious"), - dictgen::InsensitiveStr::Ascii("nty"), - dictgen::InsensitiveStr::Ascii("tance"), - dictgen::InsensitiveStr::Ascii("tutionalized"), + dictgen::InsensitiveStr::Ascii("ance"), + dictgen::InsensitiveStr::Ascii("iate"), + dictgen::InsensitiveStr::Ascii("utionalized"), + ], + values: &[&["instance"], &["instantiate"], &["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("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("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("tiaties"), + dictgen::InsensitiveStr::Ascii("ty"), + dictgen::InsensitiveStr::Ascii("ze"), ], values: &[ - &["instability"], - &["instability"], - &["instability"], - &["instability"], - &["instead"], - &["installations"], - &["installation"], - &["installment"], - &["installations"], - &["installations"], - &["installation"], - &["installer"], - &["installer"], - &["installment"], - &["installment"], - &["installs"], - &["installs"], - &["installing"], - &["installing"], - &["installment"], - &["installs"], + &["instance"], &["instantiate"], + &["instantiated"], + &["instantiates"], + &["instantiating"], + &["instantiation"], + &["instantiations"], + &["instance"], &["instances"], + &["instances"], + &["instantiation"], + &["instantiate"], + &["instantiated"], + &["instantiates"], + &["instantiation"], &["instantaneous"], &["instantaneous"], &["instantaneous"], @@ -46824,13 +87094,149 @@ pub static WORD_INSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["instantaneous"], &["instantaneous"], &["instantaneous"], + &["instantiate"], + &["instantiating"], + &["instantiation"], + &["instantiations"], &["instantaneous"], &["instantaneous"], + &["instantiates"], &["instantly"], &["instance"], - &["institutionalized"], ], - range: 2..=12, + 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("ed"), + dictgen::InsensitiveStr::Ascii("ement"), + 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("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("lling"), + dictgen::InsensitiveStr::Ascii("lmant"), + dictgen::InsensitiveStr::Ascii("ltion"), + dictgen::InsensitiveStr::Ascii("lus"), + ], + values: &[ + &["installations"], + &["installation"], + &["installations"], + &["installed"], + &["installment"], + &["installing"], + &["installation"], + &["installation"], + &["installations"], + &["installation"], + &["installations"], + &["installation"], + &["installations"], + &["installation"], + &["installations"], + &["installation"], + &["installer", "installed", "install"], + &["installer"], + &["installer"], + &["installment"], + &["installment"], + &["installs"], + &["installs"], + &["installing"], + &["installing"], + &["installment"], + &["installation"], + &["installs"], + ], + range: 2..=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_INSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46871,6 +87277,7 @@ pub static WORD_INSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -46897,12 +87304,13 @@ pub static WORD_INSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["inspired"], &["inspires"], &["inspirational"], + &["inspire"], &["inspiration"], &["inspirational"], &["inspired"], &["inspires"], ], - range: 4..=10, + range: 3..=10, }; static WORD_INSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46914,9 +87322,10 @@ pub static WORD_INSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("mina"), dictgen::InsensitiveStr::Ascii("nmia"), + dictgen::InsensitiveStr::Ascii("nsistency"), ], - values: &[&["insomnia"], &["insomnia"]], - range: 4..=4, + values: &[&["insomnia"], &["insomnia"], &["inconsistency"]], + range: 4..=9, }; static WORD_INSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -46951,6 +87360,7 @@ static WORD_INSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_INSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ded"), dictgen::InsensitiveStr::Ascii("dios"), dictgen::InsensitiveStr::Ascii("diuos"), dictgen::InsensitiveStr::Ascii("ginficant"), @@ -46960,7 +87370,10 @@ pub static WORD_INSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -46975,10 +87388,12 @@ pub static WORD_INSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["insidious"], &["insidious"], &["insignificant"], @@ -46988,6 +87403,9 @@ pub static WORD_INSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["insignificant"], &["insignificant"], &["insignificant"], + &["insight"], + &["insight"], + &["insights"], &["insights"], &["insinuating"], &["inspiration"], @@ -47003,10 +87421,11 @@ pub static WORD_INSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["insists"], &["insistence"], &["insists"], + &["institute"], &["institution"], &["institutions"], ], - range: 3..=9, + range: 2..=9, }; static WORD_INSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47023,7 +87442,12 @@ pub static WORD_INSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("curitites"), dictgen::InsensitiveStr::Ascii("nsative"), dictgen::InsensitiveStr::Ascii("nsetive"), + dictgen::InsensitiveStr::Ascii("nsistive"), + dictgen::InsensitiveStr::Ascii("nsistively"), + dictgen::InsensitiveStr::Ascii("nsitivy"), dictgen::InsensitiveStr::Ascii("nsitve"), + dictgen::InsensitiveStr::Ascii("nstive"), + dictgen::InsensitiveStr::Ascii("nstively"), dictgen::InsensitiveStr::Ascii("ntitive"), dictgen::InsensitiveStr::Ascii("ntivised"), dictgen::InsensitiveStr::Ascii("ntivises"), @@ -47031,10 +87455,26 @@ pub static WORD_INSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ring"), + dictgen::InsensitiveStr::Ascii("rsect"), + dictgen::InsensitiveStr::Ascii("rsected"), + dictgen::InsensitiveStr::Ascii("rsecting"), + dictgen::InsensitiveStr::Ascii("rsects"), 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("tad"), + dictgen::InsensitiveStr::Ascii("ted"), ], values: &[ &["insects"], @@ -47045,6 +87485,11 @@ pub static WORD_INSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["insensitive"], &["insensitive"], &["insensitive"], + &["insensitively"], + &["insensitivity"], + &["insensitive"], + &["insensitive"], + &["insensitively"], &["insensitive"], &["insensitive"], &["insensitive"], @@ -47052,12 +87497,39 @@ pub static WORD_INSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["inspection"], &["inspections"], &["inspector"], + &["inspect"], + &["inspected"], + &["inspection"], + &["inspects"], + &["independent"], &["inseparable"], + &["inception"], + &["inserting"], + &["intersect"], + &["intersected"], + &["intersecting"], + &["intersects"], &["inserts"], &["inserts"], + &["inserting"], + &["inserting"], &["inserts"], + &["insensitive"], + &["instead"], + &["inserted"], ], - range: 3..=9, + range: 3..=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 { @@ -47066,9 +87538,19 @@ static WORD_INSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_INSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ets")], - values: &[&["insects"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("ets"), + dictgen::InsensitiveStr::Ascii("peting"), + dictgen::InsensitiveStr::Ascii("tuction"), + dictgen::InsensitiveStr::Ascii("tuctions"), + ], + values: &[ + &["insects"], + &["inspecting"], + &["instruction"], + &["instructions"], + ], + range: 3..=8, }; static WORD_INSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47078,12 +87560,22 @@ static WORD_INSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_INSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("llation"), + dictgen::InsensitiveStr::Ascii("lled"), + dictgen::InsensitiveStr::Ascii("nce"), dictgen::InsensitiveStr::Ascii("nelly"), dictgen::InsensitiveStr::Ascii("ney"), dictgen::InsensitiveStr::Ascii("nley"), ], - values: &[&["insanely"], &["insanely"], &["insanely"]], - range: 3..=5, + values: &[ + &["installation"], + &["installed"], + &["instance", "insane"], + &["insanely"], + &["insanely"], + &["insanely"], + ], + range: 3..=7, }; static WORD_INR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47093,18 +87585,24 @@ static WORD_INR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_INR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[ + &["interactive"], + &["interface"], &["irresponsible"], &["unresponsive"], &["inserted"], &["inserting"], + &["into"], ], - range: 5..=10, + range: 1..=10, }; static WORD_INQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47171,6 +87669,10 @@ static WORD_INP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ection"), dictgen::InsensitiveStr::Ascii("ending"), @@ -47179,14 +87681,29 @@ pub static WORD_INP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ersonating"), 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("overished"), 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"), @@ -47196,8 +87713,18 @@ pub static WORD_INP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["inception"], &["impending"], @@ -47206,14 +87733,29 @@ pub static WORD_INP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["impersonating"], &["implementation"], &["implementations"], + &["implemented"], &["implementing"], &["implications"], + &["implicit"], + &["implicitly"], &["impolite"], + &["import"], + &["important"], + &["impossible"], &["impossibility"], + &["impossible"], &["impoverished"], &["unpredictable"], &["imprisonment"], &["unproductive"], + &["improve"], + &["improved"], + &["improves"], + &["improving"], + &["improvement"], + &["improvements"], + &["improper"], + &["improperly"], &["improvements"], &["improving"], &["inspect"], @@ -47223,8 +87765,14 @@ pub static WORD_INP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inspire"], &["inspired"], &["inspiring"], + &["interpreter"], + &["input"], + &["input", "inputs"], + &["inputted"], + &["inputstream"], + &["input"], ], - range: 4..=12, + range: 1..=12, }; static WORD_INO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47236,11 +87784,24 @@ pub static WORD_INO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("cence"), dictgen::InsensitiveStr::Ascii("fficial"), + dictgen::InsensitiveStr::Ascii("frmation"), + dictgen::InsensitiveStr::Ascii("quous"), dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("ut"), + dictgen::InsensitiveStr::Ascii("uts"), dictgen::InsensitiveStr::Ascii("vker"), ], - values: &[&["innocence"], &["unofficial"], &["into"], &["invoker"]], - range: 1..=7, + values: &[ + &["innocence"], + &["unofficial"], + &["information"], + &["innocuous"], + &["into"], + &["input"], + &["inputs"], + &["invoker"], + ], + range: 1..=8, }; static WORD_INN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47250,15 +87811,24 @@ static WORD_INN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -47272,15 +87842,24 @@ pub static WORD_INN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("voation"), ], values: &[ + &["inactive"], + &["inaccurate"], + &["inaccurately"], + &["inappropriate"], + &["ineffectual"], &["intersection"], &["interstellar"], + &["initialize", "initializes"], &["innovations"], &["innocents"], &["innocents"], &["innocents"], &["innocents"], + &["innocuous"], + &["inoculate"], &["inoculated"], &["innocuous"], + &["innocence"], &["innovation"], &["innocuous"], &["innovation"], @@ -47293,7 +87872,7 @@ pub static WORD_INN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["innovate"], &["innovation"], ], - range: 5..=9, + range: 5..=11, }; static WORD_INM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47303,11 +87882,30 @@ static WORD_INM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["immigrant"], &["immigrants"]], - range: 6..=7, + 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 { @@ -47317,20 +87915,56 @@ static WORD_INL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 4..=9, + range: 2..=9, }; static WORD_INK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47370,92 +88004,523 @@ pub static WORD_INJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_INI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INI_CHILDREN), value: None, }; -pub static WORD_INI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_INI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_INIA_NODE), + None, + None, + Some(&WORD_INID_NODE), + None, + Some(&WORD_INIF_NODE), + None, + None, + None, + 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("dans"), - dictgen::InsensitiveStr::Ascii("fnite"), - dictgen::InsensitiveStr::Ascii("fnitely"), - dictgen::InsensitiveStr::Ascii("fnity"), - dictgen::InsensitiveStr::Ascii("ntelligent"), - dictgen::InsensitiveStr::Ascii("nterested"), - dictgen::InsensitiveStr::Ascii("nteresting"), - dictgen::InsensitiveStr::Ascii("sghts"), - dictgen::InsensitiveStr::Ascii("tailly"), - dictgen::InsensitiveStr::Ascii("tails"), - dictgen::InsensitiveStr::Ascii("taite"), - dictgen::InsensitiveStr::Ascii("taition"), - dictgen::InsensitiveStr::Ascii("taitives"), - dictgen::InsensitiveStr::Ascii("tal"), - dictgen::InsensitiveStr::Ascii("taled"), - dictgen::InsensitiveStr::Ascii("talese"), - dictgen::InsensitiveStr::Ascii("taling"), - dictgen::InsensitiveStr::Ascii("talisation"), - dictgen::InsensitiveStr::Ascii("talisations"), - dictgen::InsensitiveStr::Ascii("talise"), - dictgen::InsensitiveStr::Ascii("talised"), - dictgen::InsensitiveStr::Ascii("taliser"), - dictgen::InsensitiveStr::Ascii("talisers"), - dictgen::InsensitiveStr::Ascii("talises"), - dictgen::InsensitiveStr::Ascii("talising"), - dictgen::InsensitiveStr::Ascii("talism"), - dictgen::InsensitiveStr::Ascii("talisms"), - dictgen::InsensitiveStr::Ascii("talizable"), - dictgen::InsensitiveStr::Ascii("talization"), - dictgen::InsensitiveStr::Ascii("talizations"), - dictgen::InsensitiveStr::Ascii("talize"), - dictgen::InsensitiveStr::Ascii("talized"), - dictgen::InsensitiveStr::Ascii("talizer"), - dictgen::InsensitiveStr::Ascii("talizers"), - dictgen::InsensitiveStr::Ascii("talizes"), - dictgen::InsensitiveStr::Ascii("talizing"), - dictgen::InsensitiveStr::Ascii("talled"), - dictgen::InsensitiveStr::Ascii("talling"), - dictgen::InsensitiveStr::Ascii("tally"), - dictgen::InsensitiveStr::Ascii("talness"), - dictgen::InsensitiveStr::Ascii("tals"), - dictgen::InsensitiveStr::Ascii("tation"), - dictgen::InsensitiveStr::Ascii("tiaitive"), - dictgen::InsensitiveStr::Ascii("tiaitve"), - dictgen::InsensitiveStr::Ascii("tiales"), - dictgen::InsensitiveStr::Ascii("tialy"), - dictgen::InsensitiveStr::Ascii("tiatie"), - dictgen::InsensitiveStr::Ascii("tiaties"), - dictgen::InsensitiveStr::Ascii("tiatin"), - dictgen::InsensitiveStr::Ascii("tiativs"), - dictgen::InsensitiveStr::Ascii("tiatve"), - dictgen::InsensitiveStr::Ascii("tiatves"), - dictgen::InsensitiveStr::Ascii("tiavite"), - dictgen::InsensitiveStr::Ascii("tisl"), - dictgen::InsensitiveStr::Ascii("titaive"), - dictgen::InsensitiveStr::Ascii("titiave"), - dictgen::InsensitiveStr::Ascii("titiaves"), - dictgen::InsensitiveStr::Ascii("tmacy"), - dictgen::InsensitiveStr::Ascii("tmate"), - dictgen::InsensitiveStr::Ascii("tmately"), - dictgen::InsensitiveStr::Ascii("tmidate"), - dictgen::InsensitiveStr::Ascii("tuition"), + 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("ialization"), + dictgen::InsensitiveStr::Ascii("ition"), + ], + values: &[&["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: &[ - &["indians"], - &["infinite"], - &["infinitely"], - &["infinity"], - &["unintelligent"], - &["uninterested"], - &["uninteresting"], - &["insights"], + &["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("ate"), + dictgen::InsensitiveStr::Ascii("ator"), + dictgen::InsensitiveStr::Ascii("iave"), + dictgen::InsensitiveStr::Ascii("iaves"), + ], + values: &[ + &["initiatives"], + &["initiate"], + &["initiator"], + &["initiatives"], + &["initiatives"], + ], + range: 3..=5, +}; + +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("ialised"), + dictgen::InsensitiveStr::Ascii("ialized"), + 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("izes"), + dictgen::InsensitiveStr::Ascii("izing"), + ], + values: &[ + &["initialised"], + &["initialized"], + &["initialise", "initialise"], + &["initialised", "initialised"], + &["initialises", "initialises"], + &["initialising", "initialising"], + &["initialize"], + &["initialized"], + &["initializes"], + &["initializing"], + &["initialisation", "initialisation"], + &["initialisations", "initialisations"], + &["initialise", "initialise"], + &["initialised", "initialised"], + &["initialises", "initialises"], + &["initialising", "initialising"], + &["initialization"], + &["initializations"], + &["initialize"], + &["initialized"], + &["initializes"], + &["initializing"], + ], + range: 3..=8, +}; + +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::Flat(&WORD_INITIA_CHILDREN), + value: None, +}; + +pub static WORD_INITIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("itive"), + dictgen::InsensitiveStr::Ascii("itve"), + dictgen::InsensitiveStr::Ascii("les"), + dictgen::InsensitiveStr::Ascii("lialize"), + dictgen::InsensitiveStr::Ascii("liase"), + dictgen::InsensitiveStr::Ascii("liation"), + dictgen::InsensitiveStr::Ascii("liazation"), + dictgen::InsensitiveStr::Ascii("liaze"), + dictgen::InsensitiveStr::Ascii("liazed"), + dictgen::InsensitiveStr::Ascii("lied"), + dictgen::InsensitiveStr::Ascii("lilzing"), + dictgen::InsensitiveStr::Ascii("lisiert"), + dictgen::InsensitiveStr::Ascii("liting"), + dictgen::InsensitiveStr::Ascii("litze"), + dictgen::InsensitiveStr::Ascii("litzing"), + dictgen::InsensitiveStr::Ascii("lizaing"), + dictgen::InsensitiveStr::Ascii("lizaiton"), + dictgen::InsensitiveStr::Ascii("lizatin"), + dictgen::InsensitiveStr::Ascii("lizationg"), + dictgen::InsensitiveStr::Ascii("lizeing"), + dictgen::InsensitiveStr::Ascii("liziation"), + dictgen::InsensitiveStr::Ascii("lizong"), + dictgen::InsensitiveStr::Ascii("lizs"), + dictgen::InsensitiveStr::Ascii("lse"), + dictgen::InsensitiveStr::Ascii("lsed"), + dictgen::InsensitiveStr::Ascii("lses"), + dictgen::InsensitiveStr::Ascii("lsing"), + dictgen::InsensitiveStr::Ascii("ly"), + dictgen::InsensitiveStr::Ascii("lyl"), + dictgen::InsensitiveStr::Ascii("lyse"), + dictgen::InsensitiveStr::Ascii("lysed"), + dictgen::InsensitiveStr::Ascii("lyses"), + dictgen::InsensitiveStr::Ascii("lysing"), + dictgen::InsensitiveStr::Ascii("lyze"), + dictgen::InsensitiveStr::Ascii("lyzed"), + dictgen::InsensitiveStr::Ascii("lyzes"), + dictgen::InsensitiveStr::Ascii("lyzing"), + dictgen::InsensitiveStr::Ascii("lzation"), + dictgen::InsensitiveStr::Ascii("lze"), + dictgen::InsensitiveStr::Ascii("lzed"), + dictgen::InsensitiveStr::Ascii("lzes"), + dictgen::InsensitiveStr::Ascii("lzing"), + dictgen::InsensitiveStr::Ascii("tie"), + dictgen::InsensitiveStr::Ascii("ties"), + dictgen::InsensitiveStr::Ascii("tin"), + dictgen::InsensitiveStr::Ascii("tivs"), + dictgen::InsensitiveStr::Ascii("tve"), + dictgen::InsensitiveStr::Ascii("tves"), + dictgen::InsensitiveStr::Ascii("vite"), + ], + values: &[ + &["initiative"], + &["initiatives"], + &[ + "initials", + "initialise", + "initializes", + "initialise", + "initialises", + ], + &["initialize"], + &["initialise", "initialise"], + &["initialization"], + &["initialization"], + &["initialize"], + &["initialized"], + &["initialized"], + &["initializing"], + &["initialised", "initialised"], + &["initializing"], + &["initialize"], + &["initializing"], + &["initializing"], + &["initialization"], + &["initialization"], + &["initialization"], + &["initializing"], + &["initialization"], + &["initializing"], + &["initialize", "initializes"], + &["initialise", "initialise"], + &["initialised", "initialised"], + &["initialises", "initialises"], + &["initialising"], + &["initially"], + &["initially"], + &["initialise", "initialise"], + &["initialised", "initialised"], + &["initialises", "initialises"], + &["initialising", "initialising"], + &["initialize"], + &["initialized"], + &["initializes"], + &["initializing"], + &["initialization"], + &["initialize"], + &["initialized"], + &["initializes"], + &["initializing"], + &["initiatives"], + &["initiatives"], + &["initiation"], + &["initiatives"], + &["initiate"], + &["initiatives"], + &["initiatives"], + ], + range: 2..=9, +}; + +static WORD_INITA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_INITA_CHILDREN), + value: None, +}; + +pub static WORD_INITA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("il"), + dictgen::InsensitiveStr::Ascii("ilisation"), + dictgen::InsensitiveStr::Ascii("ilise"), + dictgen::InsensitiveStr::Ascii("ilised"), + dictgen::InsensitiveStr::Ascii("iliser"), + dictgen::InsensitiveStr::Ascii("ilisers"), + dictgen::InsensitiveStr::Ascii("ilises"), + dictgen::InsensitiveStr::Ascii("ilising"), + dictgen::InsensitiveStr::Ascii("ilization"), + dictgen::InsensitiveStr::Ascii("ilize"), + dictgen::InsensitiveStr::Ascii("ilized"), + dictgen::InsensitiveStr::Ascii("ilizer"), + dictgen::InsensitiveStr::Ascii("ilizers"), + dictgen::InsensitiveStr::Ascii("ilizes"), + dictgen::InsensitiveStr::Ascii("ilizing"), + dictgen::InsensitiveStr::Ascii("illy"), + dictgen::InsensitiveStr::Ascii("ils"), + dictgen::InsensitiveStr::Ascii("ilsation"), + dictgen::InsensitiveStr::Ascii("ilse"), + dictgen::InsensitiveStr::Ascii("ilsed"), + dictgen::InsensitiveStr::Ascii("ilsiation"), + dictgen::InsensitiveStr::Ascii("ily"), + dictgen::InsensitiveStr::Ascii("ilzation"), + dictgen::InsensitiveStr::Ascii("ilze"), + dictgen::InsensitiveStr::Ascii("ilzed"), + dictgen::InsensitiveStr::Ascii("ilziation"), + dictgen::InsensitiveStr::Ascii("ite"), + dictgen::InsensitiveStr::Ascii("ition"), + dictgen::InsensitiveStr::Ascii("itives"), + dictgen::InsensitiveStr::Ascii("l"), + dictgen::InsensitiveStr::Ascii("led"), + dictgen::InsensitiveStr::Ascii("lese"), + dictgen::InsensitiveStr::Ascii("lialization"), + dictgen::InsensitiveStr::Ascii("ling"), + dictgen::InsensitiveStr::Ascii("lisation"), + dictgen::InsensitiveStr::Ascii("lisations"), + 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("lism"), + dictgen::InsensitiveStr::Ascii("lisms"), + dictgen::InsensitiveStr::Ascii("lizable"), + dictgen::InsensitiveStr::Ascii("lization"), + dictgen::InsensitiveStr::Ascii("lizations"), + 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("lled"), + dictgen::InsensitiveStr::Ascii("lling"), + dictgen::InsensitiveStr::Ascii("lly"), + dictgen::InsensitiveStr::Ascii("lness"), + dictgen::InsensitiveStr::Ascii("ls"), + dictgen::InsensitiveStr::Ascii("te"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tors"), + ], + 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"], &["initial"], &["initialed"], &["initialese"], + &["initialization"], &["initialing"], &["initialisation"], &["initialisations"], @@ -47481,29 +88546,96 @@ pub static WORD_INI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["initially"], &["initialness"], &["initials"], + &["initiate", "imitate"], + &["initiated", "imitated"], &["initiation"], - &["initiative"], - &["initiatives"], - &["initials"], - &["initially"], - &["initiatives"], - &["initiatives"], - &["initiation"], - &["initiatives"], - &["initiate"], - &["initiatives"], - &["initiatives"], - &["initials"], - &["initiatives"], - &["initiatives"], - &["initiatives"], - &["intimacy"], - &["intimate"], - &["intimately"], - &["intimidate"], - &["initiation"], + &["initiators"], ], - range: 3..=11, + range: 1..=11, +}; + +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")], + values: &[&["insights"]], + range: 4..=4, +}; + +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("tialization"), + ], + values: &[ + &["unintelligent"], + &["uninterested"], + &["uninteresting"], + &["initialization"], + ], + range: 8..=11, +}; + +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("inte"), + dictgen::InsensitiveStr::Ascii("nite"), + dictgen::InsensitiveStr::Ascii("nitely"), + dictgen::InsensitiveStr::Ascii("nity"), + ], + values: &[ + &["infinite"], + &["infinite"], + &["infinite"], + &["infinitely"], + &["infinity"], + ], + range: 4..=6, +}; + +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("icates"), + dictgen::InsensitiveStr::Ascii("vidual"), + ], + values: &[&["indians"], &["indicates"], &["individual"]], + range: 3..=6, +}; + +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("lized"), + dictgen::InsensitiveStr::Ascii("te"), + ], + values: &[&["initialized"], &["initiate"]], + range: 2..=5, }; static WORD_INH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47522,15 +88654,31 @@ pub static WORD_INH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("eriet"), dictgen::InsensitiveStr::Ascii("erint"), dictgen::InsensitiveStr::Ascii("erintly"), + dictgen::InsensitiveStr::Ascii("eritablility"), dictgen::InsensitiveStr::Ascii("eritage"), dictgen::InsensitiveStr::Ascii("eritence"), + 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("ertiance"), dictgen::InsensitiveStr::Ascii("ertied"), + dictgen::InsensitiveStr::Ascii("ertig"), + dictgen::InsensitiveStr::Ascii("erting"), + dictgen::InsensitiveStr::Ascii("omogenous"), dictgen::InsensitiveStr::Ascii("umaan"), dictgen::InsensitiveStr::Ascii("umain"), ], @@ -47544,19 +88692,35 @@ pub static WORD_INH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inherited"], &["inherently"], &["inheritance"], + &["inherit"], &["inheritance"], + &["inherits"], &["inherit"], &["inherit"], &["inherently"], - &["heritage"], + &["inheritability"], + &["heritage", "inheritance"], &["inheritance"], + &["inherit"], + &["inherited"], + &["inheriting"], + &["inherits"], + &["inherited"], &["inherently"], + &["inherit"], &["inheritance"], &["inherited"], + &["inheriting"], + &["inherits"], + &["inheritance"], + &["inherited"], + &["inheriting", "inherited"], + &["inheriting"], + &["inhomogeneous"], &["inhuman"], &["inhuman"], ], - range: 4..=8, + range: 4..=12, }; static WORD_ING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47566,6 +88730,7 @@ static WORD_ING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("egral"), dictgen::InsensitiveStr::Ascii("enius"), dictgen::InsensitiveStr::Ascii("eniuty"), dictgen::InsensitiveStr::Ascii("enuitiy"), @@ -47573,9 +88738,19 @@ pub static WORD_ING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -47587,6 +88762,7 @@ pub static WORD_ING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("uenity"), ], values: &[ + &["integral"], &["ingenious"], &["ingenuity"], &["ingenuity"], @@ -47594,9 +88770,19 @@ pub static WORD_ING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["investigator"], &["ingenuity"], &["ignition"], + &["ignore", "ignorant"], + &["ignore"], + &["ignored"], + &["ignores"], + &["ignoring"], &["incognito"], &["ignorance"], &["ignorant"], + &["ignore"], + &["ignored"], + &["ignores"], + &["ignoring"], + &["integration"], &["ingredient"], &["ingredients"], &["ingredients"], @@ -47607,7 +88793,7 @@ pub static WORD_ING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["ingredient"], &["ingenuity"], ], - range: 5..=9, + range: 3..=9, }; static WORD_INF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47668,6 +88854,7 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("antryman"), dictgen::InsensitiveStr::Ascii("aread"), + dictgen::InsensitiveStr::Ascii("asctructure"), dictgen::InsensitiveStr::Ascii("astracture"), dictgen::InsensitiveStr::Ascii("astructre"), dictgen::InsensitiveStr::Ascii("astructuur"), @@ -47675,7 +88862,17 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("astrucutre"), dictgen::InsensitiveStr::Ascii("astrukture"), dictgen::InsensitiveStr::Ascii("astrutture"), + dictgen::InsensitiveStr::Ascii("astruture"), 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"), @@ -47685,9 +88882,12 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -47700,6 +88900,17 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["infrastructure"], &["infrastructure"], &["infrastructure"], + &["infrastructure"], + &["infrastructure"], + &["infrequency"], + &["infrequency"], + &["infrequency"], + &["infrequency"], + &["infrequencies"], + &["infrequency"], + &["infrequencies"], + &["infrequency"], + &["infrequencies"], &["infringement"], &["infringing"], &["infringement"], @@ -47709,11 +88920,14 @@ pub static WORD_INFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["informal"], &["information"], &["informative"], + &["information"], &["informed"], &["informs"], + &["information"], &["infront"], + &["infrastructure"], ], - range: 3..=10, + range: 3..=11, }; static WORD_INFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47723,6 +88937,7 @@ static WORD_INFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -47730,28 +88945,54 @@ pub static WORD_INFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("grpahic"), dictgen::InsensitiveStr::Ascii("grpahics"), dictgen::InsensitiveStr::Ascii("mation"), + dictgen::InsensitiveStr::Ascii("mational"), + dictgen::InsensitiveStr::Ascii("med"), + dictgen::InsensitiveStr::Ascii("mer"), + 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("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("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"], @@ -47759,13 +89000,27 @@ pub static WORD_INFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["infographic"], &["infographic"], &["information"], + &["informational"], + &["informed"], + &["informer"], + &["informs"], + &["info"], + &["information"], + &["information"], + &["informational"], + &["enforce"], + &["enforced"], &["unforgivable"], &["informal"], &["information"], + &["information"], + &["information"], &["informal"], &["informal"], &["informal"], &["informs"], + &["information"], + &["information"], &["informative"], &["informative"], &["informative"], @@ -47773,14 +89028,25 @@ pub static WORD_INFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["informative"], &["informative"], &["information"], + &["information", "informing"], + &["information"], + &["information"], + &["information"], + &["information"], + &["information"], + &["information"], + &["information"], + &["information"], &["informal"], &["informed"], + &["information"], &["informs"], &["informative"], &["information"], &["infront"], + &["information"], ], - range: 3..=8, + range: 1..=10, }; static WORD_INFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -47797,16 +89063,23 @@ pub static WORD_INFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -47830,17 +89103,24 @@ pub static WORD_INFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["inflatable"], &["inflatable"], &["inflate"], + &["inflation"], &["influenced"], + &["inflexible"], &["infiltrate"], &["infiltrator"], &["influenced"], &["influences"], &["influencing"], + &["influence"], + &["influenced"], + &["influences"], + &["influencing"], &["influencing"], &["influential"], &["influencing"], &["influences"], &["influencing"], + &["influencing"], &["influences"], &["influences"], &["influences"], @@ -47890,6 +89170,7 @@ pub static WORD_INFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -47897,10 +89178,13 @@ pub static WORD_INFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), ], values: &[ &["infidelity"], @@ -47929,16 +89213,20 @@ pub static WORD_INFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["infinite"], &["infinite"], &["infinite"], + &["infinite"], &["infinitely"], &["infinity"], &["infinite"], &["infinity"], &["infinitely"], - &["infinity"], + &["infinity", "infinitely"], + &["infinite"], + &["infinitesimal"], &["infinite"], &["infinitely"], &["infinity"], &["infiltrator"], + &["infinity"], ], range: 3..=9, }; @@ -47959,6 +89247,8 @@ pub static WORD_INFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -47967,12 +89257,14 @@ pub static WORD_INFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -47984,6 +89276,8 @@ pub static WORD_INFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["infectious"], &["inferno"], &["inferred"], + &["interface"], + &["inferring"], &["inferior"], &["inferior"], &["inferior"], @@ -47992,14 +89286,16 @@ pub static WORD_INFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["inferior"], &["inferior"], &["inferno"], + &["inferable"], &["inference"], &["infestation"], &["infestation"], &["infestation"], &["infestation"], &["infections"], + &["index"], ], - range: 3..=7, + range: 1..=7, }; static WORD_INFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48016,6 +89312,9 @@ pub static WORD_INFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -48026,8 +89325,11 @@ pub static WORD_INFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["infallible"], &["infallible"], &["infallible"], - &["inflatable"], + &["inflatable", "infallible"], &["inflate"], + &["inflated"], + &["inflates"], + &["inflating"], &["infants"], &["infants"], &["infrared"], @@ -48036,103 +89338,83 @@ pub static WORD_INFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_INE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INE_CHILDREN), value: None, }; -pub static WORD_INE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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: None, +}; + +pub static WORD_INEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("ffecitve"), - dictgen::InsensitiveStr::Ascii("ffektive"), - dictgen::InsensitiveStr::Ascii("fficeint"), - dictgen::InsensitiveStr::Ascii("fficent"), - dictgen::InsensitiveStr::Ascii("fficiant"), - dictgen::InsensitiveStr::Ascii("fficienct"), - dictgen::InsensitiveStr::Ascii("fficienty"), - dictgen::InsensitiveStr::Ascii("ffictive"), - dictgen::InsensitiveStr::Ascii("ffizient"), - dictgen::InsensitiveStr::Ascii("qaulity"), - dictgen::InsensitiveStr::Ascii("quailty"), - dictgen::InsensitiveStr::Ascii("quallity"), - dictgen::InsensitiveStr::Ascii("rsting"), - dictgen::InsensitiveStr::Ascii("vatible"), - dictgen::InsensitiveStr::Ascii("vetable"), - dictgen::InsensitiveStr::Ascii("vetably"), - dictgen::InsensitiveStr::Ascii("vetible"), - dictgen::InsensitiveStr::Ascii("vidable"), - dictgen::InsensitiveStr::Ascii("vidably"), - dictgen::InsensitiveStr::Ascii("vitabile"), - dictgen::InsensitiveStr::Ascii("vitabily"), - dictgen::InsensitiveStr::Ascii("vitablely"), - dictgen::InsensitiveStr::Ascii("vitabley"), - dictgen::InsensitiveStr::Ascii("vitablity"), - dictgen::InsensitiveStr::Ascii("vitablly"), - dictgen::InsensitiveStr::Ascii("vitible"), - dictgen::InsensitiveStr::Ascii("vitibly"), - dictgen::InsensitiveStr::Ascii("vititably"), - dictgen::InsensitiveStr::Ascii("vtiable"), - dictgen::InsensitiveStr::Ascii("vtiably"), - dictgen::InsensitiveStr::Ascii("xblicably"), - dictgen::InsensitiveStr::Ascii("xeprienced"), - dictgen::InsensitiveStr::Ascii("xpectedly"), - dictgen::InsensitiveStr::Ascii("xpeirenced"), - dictgen::InsensitiveStr::Ascii("xpencive"), - dictgen::InsensitiveStr::Ascii("xpenisve"), - dictgen::InsensitiveStr::Ascii("xpense"), - dictgen::InsensitiveStr::Ascii("xpereince"), - dictgen::InsensitiveStr::Ascii("xpereinced"), - dictgen::InsensitiveStr::Ascii("xperiance"), - dictgen::InsensitiveStr::Ascii("xperianced"), - dictgen::InsensitiveStr::Ascii("xperiece"), - dictgen::InsensitiveStr::Ascii("xperieced"), - dictgen::InsensitiveStr::Ascii("xperiecned"), - dictgen::InsensitiveStr::Ascii("xperiencable"), - dictgen::InsensitiveStr::Ascii("xperiened"), - dictgen::InsensitiveStr::Ascii("xperiente"), - dictgen::InsensitiveStr::Ascii("xperince"), - dictgen::InsensitiveStr::Ascii("xperineced"), - dictgen::InsensitiveStr::Ascii("xpierence"), - dictgen::InsensitiveStr::Ascii("xpierenced"), - dictgen::InsensitiveStr::Ascii("xplicabil"), - dictgen::InsensitiveStr::Ascii("xplicablely"), - dictgen::InsensitiveStr::Ascii("xplicabley"), - dictgen::InsensitiveStr::Ascii("xplicablly"), - dictgen::InsensitiveStr::Ascii("xplicaby"), - dictgen::InsensitiveStr::Ascii("xplicibly"), + 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: &[ - &["ineffective"], - &["ineffective"], - &["inefficient"], - &["inefficient"], - &["inefficient"], - &["inefficient"], - &["inefficiently"], - &["ineffective"], - &["inefficient"], - &["inequality"], - &["inequality"], - &["inequality"], - &["inserting"], - &["inevitable"], - &["inevitable"], - &["inevitably"], - &["inevitable"], - &["inevitable"], - &["inevitably"], - &["inevitable"], - &["inevitably"], - &["inevitably"], - &["inevitably"], - &["inevitably"], - &["inevitably"], - &["inevitable"], - &["inevitably"], - &["inevitably"], - &["inevitable"], - &["inevitably"], &["inexplicably"], &["inexperience"], + &["inexistent"], + &["inexpected"], &["unexpectedly"], &["inexperience"], &["inexpensive"], @@ -48150,7 +89432,9 @@ pub static WORD_INE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inexperience"], &["inexperience"], &["inexperience"], + &["inexperienced", "inexperience"], &["inexperienced"], + &["inexperience"], &["inexperienced"], &["inexplicably"], &["inexplicably"], @@ -48159,7 +89443,196 @@ pub static WORD_INE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inexplicably"], &["inexplicably"], ], - range: 6..=12, + 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("nal"), + dictgen::InsensitiveStr::Ascii("rupt"), + dictgen::InsensitiveStr::Ascii("shia"), + dictgen::InsensitiveStr::Ascii("shial"), + dictgen::InsensitiveStr::Ascii("sting"), + dictgen::InsensitiveStr::Ascii("tion"), + ], + values: &[ + &["interface"], + &["internal"], + &["interrupt"], + &["inertia"], + &["inertial"], + &["inserting"], + &["insertion"], + ], + range: 3..=5, +}; + +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("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("fient"), + dictgen::InsensitiveStr::Ascii("fiently"), + dictgen::InsensitiveStr::Ascii("fizient"), + dictgen::InsensitiveStr::Ascii("icient"), + ], + values: &[ + &["ineffective"], + &["ineffective"], + &["inefficient"], + &["inefficiency"], + &["inefficient"], + &["inefficiently"], + &["inefficiently"], + &["inefficient"], + &["inefficient"], + &["inefficiently"], + &["inefficiency", "inefficiently"], + &["ineffective"], + &["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 { @@ -48170,8 +89643,8 @@ static WORD_IND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_INDA_NODE), None, - None, - None, + Some(&WORD_INDC_NODE), + Some(&WORD_INDD_NODE), Some(&WORD_INDE_NODE), None, None, @@ -48191,20 +89664,34 @@ static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_INDU_NODE), Some(&WORD_INDV_NODE), None, - 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("iduals")], - values: &[&["individuals"]], - range: 6..=6, + 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 { @@ -48216,6 +89703,7 @@ pub static WORD_INDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -48238,6 +89726,7 @@ pub static WORD_INDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["indulge"], &["indulge"], + &["endure"], &["industrial"], &["industrialized"], &["industries"], @@ -48257,7 +89746,7 @@ pub static WORD_INDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["indestructible"], &["industrial"], ], - range: 3..=10, + range: 2..=10, }; static WORD_INDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48361,8 +89850,8 @@ static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_INDIA_NODE), None, Some(&WORD_INDIC_NODE), - None, - None, + Some(&WORD_INDID_NODE), + Some(&WORD_INDIE_NODE), Some(&WORD_INDIF_NODE), Some(&WORD_INDIG_NODE), None, @@ -48374,7 +89863,7 @@ static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_INDIP_NODE), - None, + Some(&WORD_INDIQ_NODE), Some(&WORD_INDIR_NODE), Some(&WORD_INDIS_NODE), None, @@ -48383,9 +89872,20 @@ static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, 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, @@ -48393,6 +89893,14 @@ static WORD_INDIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("idaul"), + dictgen::InsensitiveStr::Ascii("idaully"), + dictgen::InsensitiveStr::Ascii("idauls"), + dictgen::InsensitiveStr::Ascii("idauly"), + dictgen::InsensitiveStr::Ascii("idial"), dictgen::InsensitiveStr::Ascii("idiual"), dictgen::InsensitiveStr::Ascii("iduais"), dictgen::InsensitiveStr::Ascii("iduales"), @@ -48402,17 +89910,31 @@ pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("idus"), + 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"], + &["individually"], + &["individual"], &["individual"], &["individuals"], &["individuals"], @@ -48422,17 +89944,23 @@ pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["individuality"], &["individual"], &["individual"], + &["individually"], + &["individuals"], + &["individually"], + &["individual"], &["individuals"], &["individual"], + &["individually"], &["individuals"], &["individuals"], &["individually"], &["individual"], + &["individual"], &["individuality"], &["individually"], &["individuals"], ], - range: 4..=9, + range: 3..=9, }; static WORD_INDIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48446,6 +89974,7 @@ pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -48462,6 +89991,7 @@ pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["indistinguishable"], &["indistinguishable"], &["indistinguishable"], + &["indistinguishable"], &["indestructible"], &["indistinguishable"], ], @@ -48489,6 +90019,20 @@ pub static WORD_INDIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -48583,6 +90127,31 @@ pub static WORD_INDIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"]], + range: 1..=1, +}; + static WORD_INDIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_INDIC_CHILDREN), value: None, @@ -48590,7 +90159,11 @@ static WORD_INDIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -48599,16 +90172,29 @@ pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], &["indicates"], &["indicative"], @@ -48616,16 +90202,25 @@ pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["indication"], &["indication"], &["indicate"], - &["indicators"], + &["indicators", "indicates", "indicate"], + &["indices"], &["incidence"], &["incidentally"], &["incidents"], + &["indicate"], + &["indicated"], + &["indicates"], + &["indicating"], + &["indices"], &["indicative"], &["indicative"], + &["indicate"], &["indictment"], + &["indicates"], + &["indicator"], &["indoctrinated"], ], - range: 3..=8, + range: 2..=8, }; static WORD_INDIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48636,6 +90231,7 @@ static WORD_INDIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -48644,9 +90240,14 @@ pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -48655,73 +90256,407 @@ pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["indiana"], &["indianapolis"], &["indians"], + &["indicate"], + &["indicated"], + &["indicates"], + &["indicating"], ], range: 2..=7, }; static WORD_INDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INDE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_INDE_CHILDREN), value: None, }; -pub static WORD_INDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_INDE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + None, + Some(&WORD_INDEC_NODE), + None, + 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, + None, + 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("fenite"), - dictgen::InsensitiveStr::Ascii("finate"), - dictgen::InsensitiveStr::Ascii("finately"), - dictgen::InsensitiveStr::Ascii("fineable"), - dictgen::InsensitiveStr::Ascii("finete"), - dictgen::InsensitiveStr::Ascii("finetely"), - dictgen::InsensitiveStr::Ascii("finetly"), - dictgen::InsensitiveStr::Ascii("fininte"), - dictgen::InsensitiveStr::Ascii("finitelly"), - dictgen::InsensitiveStr::Ascii("finitive"), - dictgen::InsensitiveStr::Ascii("finitley"), - dictgen::InsensitiveStr::Ascii("finitly"), - dictgen::InsensitiveStr::Ascii("finity"), - dictgen::InsensitiveStr::Ascii("fintiely"), - dictgen::InsensitiveStr::Ascii("ginous"), - dictgen::InsensitiveStr::Ascii("ntical"), - dictgen::InsensitiveStr::Ascii("pdenent"), - dictgen::InsensitiveStr::Ascii("pedantly"), - dictgen::InsensitiveStr::Ascii("pedence"), - dictgen::InsensitiveStr::Ascii("pednent"), - dictgen::InsensitiveStr::Ascii("pencence"), - dictgen::InsensitiveStr::Ascii("pendance"), - dictgen::InsensitiveStr::Ascii("pendant"), - dictgen::InsensitiveStr::Ascii("pendante"), - dictgen::InsensitiveStr::Ascii("pendantes"), - dictgen::InsensitiveStr::Ascii("pendantly"), - dictgen::InsensitiveStr::Ascii("pendece"), - dictgen::InsensitiveStr::Ascii("pendendet"), - dictgen::InsensitiveStr::Ascii("pendendly"), - dictgen::InsensitiveStr::Ascii("pendenet"), - dictgen::InsensitiveStr::Ascii("pendenly"), - dictgen::InsensitiveStr::Ascii("pendens"), - dictgen::InsensitiveStr::Ascii("pendense"), - dictgen::InsensitiveStr::Ascii("pendente"), - dictgen::InsensitiveStr::Ascii("pendentisme"), - dictgen::InsensitiveStr::Ascii("pendentiste"), - dictgen::InsensitiveStr::Ascii("pendentness"), - dictgen::InsensitiveStr::Ascii("pendet"), - dictgen::InsensitiveStr::Ascii("pendetly"), - dictgen::InsensitiveStr::Ascii("pendetn"), - dictgen::InsensitiveStr::Ascii("pendets"), - dictgen::InsensitiveStr::Ascii("pendnet"), - dictgen::InsensitiveStr::Ascii("penent"), - dictgen::InsensitiveStr::Ascii("pentend"), - dictgen::InsensitiveStr::Ascii("pentent"), - dictgen::InsensitiveStr::Ascii("pentently"), - dictgen::InsensitiveStr::Ascii("pentents"), - dictgen::InsensitiveStr::Ascii("rictly"), - dictgen::InsensitiveStr::Ascii("spensable"), - dictgen::InsensitiveStr::Ascii("spensible"), - dictgen::InsensitiveStr::Ascii("strictible"), - dictgen::InsensitiveStr::Ascii("structble"), - dictgen::InsensitiveStr::Ascii("structibe"), - dictgen::InsensitiveStr::Ascii("structuble"), - dictgen::InsensitiveStr::Ascii("tifiable"), + dictgen::InsensitiveStr::Ascii("ig"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("t"), + ], + values: &[&["indexing"], &["indexes", "indices"], &["index", "indent"]], + range: 1..=2, +}; + +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("pensable"), + dictgen::InsensitiveStr::Ascii("pensible"), + dictgen::InsensitiveStr::Ascii("trictible"), + dictgen::InsensitiveStr::Ascii("tructble"), + dictgen::InsensitiveStr::Ascii("tructibe"), + dictgen::InsensitiveStr::Ascii("tructuble"), + ], + values: &[ + &["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("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("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("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"], + &["independents"], + &["independence"], + &["independent"], + &["independence"], + &["independent"], + &["independents"], + &["independents"], + &["independently"], + &["independence"], + &["independent"], + &["independently"], + &["independent"], + &["independent"], + &["independently"], + &["independents"], + &["independently"], + &["independents"], + &["independents"], + &["independence"], + &["independents"], + &["independents"], + &["independents"], + &["independent"], + &["independently"], + &["independents"], + &["independents"], + &["independently"], + &["independent"], + &["independents", "independent"], + &["independent"], + &["independently"], + &["independent"], + &["independently"], + &["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("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("tit"), + dictgen::InsensitiveStr::Ascii("tity"), + dictgen::InsensitiveStr::Ascii("x"), + ], + values: &[ + &["indentation"], + &["intended", "indented"], + &["indentation"], + &["indented"], + &["identical"], + &["identically"], + &["identifier"], + &["identification"], + &["identified"], + &["identifier"], + &["identifies"], + &["identifying"], + &["identify"], + &["identifying"], + &["identity"], + &["identity"], + &["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"], @@ -48733,55 +90668,56 @@ pub static WORD_INDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["indefinitely"], &["indefinite"], &["indefinitely"], + &["indefinitely"], &["indefinite"], &["indefinitely"], &["indefinitely"], &["indefinitely"], &["indefinitely"], - &["indigenous"], - &["identical"], - &["independents"], - &["independently"], - &["independence"], - &["independents"], - &["independence"], - &["independence"], - &["independent"], - &["independents"], - &["independents"], - &["independently"], - &["independence"], - &["independent"], - &["independently"], - &["independents"], - &["independently"], - &["independents"], - &["independents"], - &["independence"], - &["independents"], - &["independents"], - &["independents"], - &["independent"], - &["independently"], - &["independents"], - &["independents"], - &["independents"], - &["independent"], - &["independents"], - &["independent"], - &["independently"], - &["independents"], - &["indirectly"], - &["indispensable"], - &["indispensable"], - &["indestructible"], - &["indestructible"], - &["indestructible"], - &["indestructible"], - &["identifiable"], - &["identification"], + &["indefinitely"], + &["indefinitely"], ], - range: 6..=11, + range: 5..=9, +}; + +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")], + values: &[&["index"]], + range: 2..=2, +}; + +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 { @@ -48816,7 +90752,7 @@ static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_INCL_NODE), - None, + Some(&WORD_INCM_NODE), None, Some(&WORD_INCO_NODE), Some(&WORD_INCP_NODE), @@ -48825,13 +90761,24 @@ static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_INCT_NODE), Some(&WORD_INCU_NODE), - None, + 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, @@ -48839,18 +90786,34 @@ static WORD_INCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[ - &["including"], + &["include"], &["included"], + &["includes"], + &["including"], + &["include"], + &["included"], + &["includes"], &["including"], &["incunabula"], + &["incur"], + &["incorruptible"], + &["incorruptible"], ], - range: 4..=5, + range: 2..=9, }; static WORD_INCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48860,11 +90823,12 @@ static WORD_INCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["introduce"], &["introduced"]], - range: 6..=7, + values: &[&["instance"], &["introduce"], &["introduced"]], + range: 4..=7, }; static WORD_INCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48878,6 +90842,9 @@ pub static WORD_INCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("amentally"), dictgen::InsensitiveStr::Ascii("aments"), dictgen::InsensitiveStr::Ascii("eadible"), + dictgen::InsensitiveStr::Ascii("eading"), + dictgen::InsensitiveStr::Ascii("eament"), + dictgen::InsensitiveStr::Ascii("eas"), dictgen::InsensitiveStr::Ascii("edable"), dictgen::InsensitiveStr::Ascii("edably"), dictgen::InsensitiveStr::Ascii("ediable"), @@ -48888,8 +90855,14 @@ pub static WORD_INCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ediblely"), dictgen::InsensitiveStr::Ascii("edibley"), dictgen::InsensitiveStr::Ascii("ediby"), + dictgen::InsensitiveStr::Ascii("emantal"), + dictgen::InsensitiveStr::Ascii("emeantal"), 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("ementarla"), dictgen::InsensitiveStr::Ascii("ementarlo"), dictgen::InsensitiveStr::Ascii("ementas"), @@ -48897,9 +90870,26 @@ pub static WORD_INCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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: &[ @@ -48907,6 +90897,9 @@ pub static WORD_INCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["incrementally"], &["increments"], &["incredible"], + &["increasing"], + &["increment"], + &["increase"], &["incredible"], &["incredibly"], &["incredible"], @@ -48917,21 +90910,44 @@ pub static WORD_INCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["incredibly"], &["incredibly"], &["incredibly"], + &["incremental"], + &["incremental"], + &["increments"], + &["increment"], + &["incremented"], + &["incremented"], + &["increments"], + &["incremental", "incrementally"], + &["incremental"], + &["incremental"], &["increments"], &["increments"], &["incremental"], &["incremental"], &["increments"], - &["increments"], + &["increment"], + &["incremental"], + &["incremented"], + &["increment"], + &["increase"], + &["increased"], + &["increases"], + &["increasing"], &["incremental"], &["incremental"], &["increments"], + &["increment"], + &["incremented"], + &["incremented"], + &["increment"], &["incremental"], - &["incremental"], + &["incrementally"], + &["incremented"], + &["incrementing"], &["increments"], &["incomprehensible"], ], - range: 5..=12, + range: 3..=12, }; static WORD_INCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -48965,11 +90981,11 @@ static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_INCOM_NODE), Some(&WORD_INCON_NODE), - None, - None, + Some(&WORD_INCOO_NODE), + Some(&WORD_INCOP_NODE), None, Some(&WORD_INCOR_NODE), - None, + Some(&WORD_INCOS_NODE), None, None, None, @@ -48979,6 +90995,20 @@ static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str 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("istent"), + dictgen::InsensitiveStr::Ascii("istente"), + ], + values: &[&["inconsistent"], &["inconsistent"]], + range: 6..=7, +}; + static WORD_INCOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_INCOR_CHILDREN), value: None, @@ -48988,13 +91018,17 @@ pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -49004,21 +91038,30 @@ pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("ruptable"), ], values: &[ &["incorrect"], &["incorrectly"], + &["incorporate"], + &["incorporates"], &["incorporated"], &["incorporate"], &["incorporate"], &["incorporated"], + &["incorporates"], &["incorporating"], &["incorporate"], &["incorporated"], + &["incorporates"], &["incorporating"], &["incorporation"], &["incorporate"], @@ -49031,76 +91074,210 @@ pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["incorrectly"], &["incorrectly"], &["incorrectly"], + &["incorrect"], + &["incorrectly"], + &["incorrect"], + &["incorrect"], + &["incorrectly"], &["incorruptible"], ], range: 3..=8, }; -static WORD_INCON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_INCON_CHILDREN), +static WORD_INCOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_INCOP_CHILDREN), value: None, }; -pub static WORD_INCON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_INCOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("cequential"), - dictgen::InsensitiveStr::Ascii("ciderate"), - dictgen::InsensitiveStr::Ascii("cistencies"), - dictgen::InsensitiveStr::Ascii("cistency"), - dictgen::InsensitiveStr::Ascii("cistent"), - dictgen::InsensitiveStr::Ascii("ditional"), - dictgen::InsensitiveStr::Ascii("ditionally"), - dictgen::InsensitiveStr::Ascii("gito"), - dictgen::InsensitiveStr::Ascii("prehensible"), - dictgen::InsensitiveStr::Ascii("sciously"), - dictgen::InsensitiveStr::Ascii("secuential"), - dictgen::InsensitiveStr::Ascii("sequantial"), - dictgen::InsensitiveStr::Ascii("sequencial"), - dictgen::InsensitiveStr::Ascii("sequental"), - dictgen::InsensitiveStr::Ascii("sequentional"), - dictgen::InsensitiveStr::Ascii("sequentual"), - dictgen::InsensitiveStr::Ascii("siderant"), - dictgen::InsensitiveStr::Ascii("siquential"), - dictgen::InsensitiveStr::Ascii("sisent"), - dictgen::InsensitiveStr::Ascii("sistance"), - dictgen::InsensitiveStr::Ascii("sistancies"), - dictgen::InsensitiveStr::Ascii("sistancy"), - dictgen::InsensitiveStr::Ascii("sistant"), - dictgen::InsensitiveStr::Ascii("sistecy"), - dictgen::InsensitiveStr::Ascii("sistencias"), - dictgen::InsensitiveStr::Ascii("sistenly"), - dictgen::InsensitiveStr::Ascii("sistensies"), - dictgen::InsensitiveStr::Ascii("sistensy"), - dictgen::InsensitiveStr::Ascii("sistentcies"), - dictgen::InsensitiveStr::Ascii("sistentcy"), - dictgen::InsensitiveStr::Ascii("sistenties"), - dictgen::InsensitiveStr::Ascii("sistenty"), - dictgen::InsensitiveStr::Ascii("sisteny"), - dictgen::InsensitiveStr::Ascii("stitutional"), - dictgen::InsensitiveStr::Ascii("trollably"), - dictgen::InsensitiveStr::Ascii("veinence"), - dictgen::InsensitiveStr::Ascii("veinent"), - dictgen::InsensitiveStr::Ascii("veniance"), - dictgen::InsensitiveStr::Ascii("veniant"), - dictgen::InsensitiveStr::Ascii("veniece"), - dictgen::InsensitiveStr::Ascii("veniente"), - dictgen::InsensitiveStr::Ascii("veniet"), - dictgen::InsensitiveStr::Ascii("venince"), - dictgen::InsensitiveStr::Ascii("ventional"), - dictgen::InsensitiveStr::Ascii("vienence"), - dictgen::InsensitiveStr::Ascii("vienenced"), - dictgen::InsensitiveStr::Ascii("vienent"), + 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"), + ], + values: &[ + &["incorporate"], + &["incorporated"], + &["incorporates"], + &["incorporating"], + &["incorporate"], + &["incorporated"], + &["incorporates"], + &["incorporating"], + ], + range: 5..=7, +}; + +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, + None, + 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("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"], + &["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: &[ - &["inconsequential"], - &["inconsiderate"], - &["inconsistencies"], - &["inconsistency"], - &["inconsistent"], - &["unconditional"], - &["unconditionally"], - &["incognito"], - &["incomprehensible"], &["unconsciously"], &["inconsequential"], &["inconsequential"], @@ -49111,36 +91288,119 @@ pub static WORD_INCON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["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"], - &["inconsistencies"], - &["inconsistency"], + &["inconsistency", "inconsistent"], + &["inconsistent"], &["inconsistency"], + &["inconsistent"], + &["inconsistent", "inconstant"], &["unconstitutional"], - &["uncontrollably"], - &["inconvenience"], - &["inconvenient"], - &["inconvenience"], - &["inconvenient"], - &["inconvenience"], - &["inconvenience"], - &["inconvenient"], - &["inconvenience"], - &["unconventional"], - &["inconvenience"], - &["inconvenience"], - &["inconvenient"], ], - range: 4..=12, + 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_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")], + values: &[&["inconsistent"]], + range: 7..=7, +}; + +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 { @@ -49150,29 +91410,57 @@ static WORD_INCOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_INCOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("apatibility"), + dictgen::InsensitiveStr::Ascii("apatible"), dictgen::InsensitiveStr::Ascii("aptible"), + dictgen::InsensitiveStr::Ascii("batibilities"), + dictgen::InsensitiveStr::Ascii("batibility"), + dictgen::InsensitiveStr::Ascii("fort"), dictgen::InsensitiveStr::Ascii("fortable"), dictgen::InsensitiveStr::Ascii("fortably"), + dictgen::InsensitiveStr::Ascii("ming"), + dictgen::InsensitiveStr::Ascii("mplete"), dictgen::InsensitiveStr::Ascii("parible"), + dictgen::InsensitiveStr::Ascii("patabable"), + dictgen::InsensitiveStr::Ascii("patabiity"), dictgen::InsensitiveStr::Ascii("patabile"), dictgen::InsensitiveStr::Ascii("patabilities"), dictgen::InsensitiveStr::Ascii("patability"), + dictgen::InsensitiveStr::Ascii("patabillity"), + dictgen::InsensitiveStr::Ascii("patabilty"), + dictgen::InsensitiveStr::Ascii("patabily"), dictgen::InsensitiveStr::Ascii("patable"), + dictgen::InsensitiveStr::Ascii("patablie"), + dictgen::InsensitiveStr::Ascii("patablility"), dictgen::InsensitiveStr::Ascii("patablities"), + dictgen::InsensitiveStr::Ascii("patablitiy"), dictgen::InsensitiveStr::Ascii("patablity"), + dictgen::InsensitiveStr::Ascii("patably"), + dictgen::InsensitiveStr::Ascii("pataibility"), + dictgen::InsensitiveStr::Ascii("pataible"), + dictgen::InsensitiveStr::Ascii("pataility"), + dictgen::InsensitiveStr::Ascii("patatbility"), + dictgen::InsensitiveStr::Ascii("patatble"), + dictgen::InsensitiveStr::Ascii("patatible"), + dictgen::InsensitiveStr::Ascii("patbility"), dictgen::InsensitiveStr::Ascii("patble"), dictgen::InsensitiveStr::Ascii("patent"), + dictgen::InsensitiveStr::Ascii("patiability"), dictgen::InsensitiveStr::Ascii("patiable"), dictgen::InsensitiveStr::Ascii("patibil"), dictgen::InsensitiveStr::Ascii("patibile"), + dictgen::InsensitiveStr::Ascii("patibilies"), dictgen::InsensitiveStr::Ascii("patiblities"), dictgen::InsensitiveStr::Ascii("patiblity"), dictgen::InsensitiveStr::Ascii("petance"), dictgen::InsensitiveStr::Ascii("petant"), + dictgen::InsensitiveStr::Ascii("pete"), dictgen::InsensitiveStr::Ascii("petente"), dictgen::InsensitiveStr::Ascii("petentence"), dictgen::InsensitiveStr::Ascii("pitable"), dictgen::InsensitiveStr::Ascii("pitent"), + dictgen::InsensitiveStr::Ascii("pleate"), + dictgen::InsensitiveStr::Ascii("pleete"), dictgen::InsensitiveStr::Ascii("potent"), dictgen::InsensitiveStr::Ascii("prehencible"), dictgen::InsensitiveStr::Ascii("prehendible"), @@ -49184,31 +91472,60 @@ pub static WORD_INCOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("prihensible"), dictgen::InsensitiveStr::Ascii("ptable"), dictgen::InsensitiveStr::Ascii("ptetent"), + dictgen::InsensitiveStr::Ascii("ptible"), ], values: &[ + &["incompatibility"], &["incompatible"], + &["incompatible"], + &["incompatibilities"], + &["incompatibility"], + &["discomfort", "uncomfortable"], &["uncomfortable"], &["uncomfortably"], + &["incoming"], + &["incomplete"], &["incompatible"], &["incompatible"], - &["incompatibilities"], &["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"], &["incompatible"], &["incompetent"], + &["incomplete"], + &["incomplete"], &["incompetent"], &["incomprehensible"], &["incomprehensible"], @@ -49220,8 +91537,9 @@ pub static WORD_INCOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["incomprehensible"], &["incompatible"], &["incompetent"], + &["incompatible"], ], - range: 6..=12, + range: 4..=12, }; static WORD_INCOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -49231,12 +91549,22 @@ static WORD_INCOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["incoherent"], &["incoherent"], &["incoherent"]], - range: 5..=6, + values: &[ + &["incoherence"], + &["incoherency"], + &["incoherent"], + &["incoherently"], + &["incoherent"], + &["incoherent"], + ], + range: 5..=7, }; static WORD_INCOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -49254,6 +91582,17 @@ pub static WORD_INCOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -49262,33 +91601,67 @@ static WORD_INCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ode"), dictgen::InsensitiveStr::Ascii("reased"), dictgen::InsensitiveStr::Ascii("ud"), + dictgen::InsensitiveStr::Ascii("udea"), dictgen::InsensitiveStr::Ascii("udeds"), + dictgen::InsensitiveStr::Ascii("udee"), + 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("usinve"), ], values: &[ &["inclination"], + &["including"], &["include"], + &["included"], + &["includes"], &["inclination"], &["inclination"], &["inclination"], &["inclination"], &["incline"], &["incline"], + &["include"], &["increased"], &["include"], + &["include"], + &["includes"], + &["include"], + &["included"], + &["including"], + &["including"], + &["including"], + &["include"], + &["included"], &["includes"], &["including"], + &["include"], + &["including"], &["includes"], + &["included"], + &["inclusive"], ], range: 2..=7, }; @@ -49350,27 +91723,35 @@ static WORD_INCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_INCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("dentally"), + dictgen::InsensitiveStr::Ascii("mentally"), 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"], + &["incrementally"], &["incentive"], &["incentive"], &["incentives"], &["incentive"], &["incentives"], &["incentives"], + &["increase"], + &["increased"], + &["increasing"], &["incarceration"], &["investigator"], ], - range: 6..=9, + range: 4..=9, }; static WORD_INCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -49380,6 +91761,7 @@ static WORD_INCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -49391,8 +91773,12 @@ pub static WORD_INCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -49404,8 +91790,11 @@ pub static WORD_INCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["incarnation"], &["incarcerated"], &["incarceration"], + &["incantation"], + &["incantations"], + &["inactive"], ], - range: 5..=9, + range: 3..=9, }; static WORD_INB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -49417,22 +91806,28 @@ pub static WORD_INB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("alance"), dictgen::InsensitiveStr::Ascii("alanced"), + 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"), ], values: &[ &["imbalance"], &["imbalanced"], + &["imbed"], + &["imbedded"], &["inbetween"], &["unbelievable"], &["inbetween"], &["inbetween"], &["inbetween"], + &["inability"], ], - range: 5..=9, + range: 2..=9, }; static WORD_INA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -49443,18 +91838,25 @@ static WORD_INA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("blility"), + dictgen::InsensitiveStr::Ascii("cccessible"), + dictgen::InsensitiveStr::Ascii("ccesible"), dictgen::InsensitiveStr::Ascii("ccesibles"), dictgen::InsensitiveStr::Ascii("ccessable"), dictgen::InsensitiveStr::Ascii("ccessbile"), dictgen::InsensitiveStr::Ascii("ccessble"), dictgen::InsensitiveStr::Ascii("ccessibile"), dictgen::InsensitiveStr::Ascii("ccruate"), + dictgen::InsensitiveStr::Ascii("ccuraccies"), + dictgen::InsensitiveStr::Ascii("ccuraccy"), dictgen::InsensitiveStr::Ascii("ccuraces"), dictgen::InsensitiveStr::Ascii("ccurasies"), dictgen::InsensitiveStr::Ascii("ccuraties"), dictgen::InsensitiveStr::Ascii("ccuricies"), dictgen::InsensitiveStr::Ascii("ccurrate"), dictgen::InsensitiveStr::Ascii("curaccies"), + dictgen::InsensitiveStr::Ascii("curate"), + dictgen::InsensitiveStr::Ascii("curracies"), + dictgen::InsensitiveStr::Ascii("currate"), dictgen::InsensitiveStr::Ascii("daquate"), dictgen::InsensitiveStr::Ascii("daquete"), dictgen::InsensitiveStr::Ascii("decuate"), @@ -49475,6 +91877,8 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("gurated"), dictgen::InsensitiveStr::Ascii("guration"), dictgen::InsensitiveStr::Ascii("hbitants"), + dictgen::InsensitiveStr::Ascii("ktively"), + dictgen::InsensitiveStr::Ascii("lid"), dictgen::InsensitiveStr::Ascii("pporpriate"), dictgen::InsensitiveStr::Ascii("pporpriately"), dictgen::InsensitiveStr::Ascii("ppropiate"), @@ -49482,6 +91886,7 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ppropraite"), dictgen::InsensitiveStr::Ascii("ppropraitely"), dictgen::InsensitiveStr::Ascii("pproprate"), + dictgen::InsensitiveStr::Ascii("ppropreate"), dictgen::InsensitiveStr::Ascii("ppropriae"), dictgen::InsensitiveStr::Ascii("ppropriatelly"), dictgen::InsensitiveStr::Ascii("ppropriatley"), @@ -49489,8 +91894,10 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ppropriet"), dictgen::InsensitiveStr::Ascii("pproprietly"), dictgen::InsensitiveStr::Ascii("proppriate"), + dictgen::InsensitiveStr::Ascii("te"), dictgen::InsensitiveStr::Ascii("ttractive"), dictgen::InsensitiveStr::Ascii("ugures"), + dictgen::InsensitiveStr::Ascii("vlid"), ], values: &[ &["inability"], @@ -49499,13 +91906,20 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inaccessible"], &["inaccessible"], &["inaccessible"], + &["inaccessible"], + &["inaccessible"], &["inaccurate"], &["inaccuracies"], + &["inaccuracy"], + &["inaccuracies"], &["inaccuracies"], &["inaccuracies"], &["inaccuracies"], &["inaccurate"], &["inaccuracies"], + &["inaccurate"], + &["inaccuracies"], + &["inaccurate"], &["inadequate"], &["inadequate"], &["inadequate"], @@ -49526,6 +91940,8 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inaugurated"], &["inauguration"], &["inhabitants"], + &["inactively"], + &["invalid"], &["inappropriate"], &["inappropriately"], &["inappropriate"], @@ -49533,6 +91949,7 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inappropriate"], &["inappropriately"], &["inappropriate"], + &["inappropriate"], &["inappropriately"], &["inappropriately"], &["inappropriately"], @@ -49540,10 +91957,12 @@ pub static WORD_INA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["inappropriately"], &["inappropriately"], &["inappropriate"], + &["innate"], &["unattractive"], &["inaugurates"], + &["invalid"], ], - range: 6..=13, + range: 2..=13, }; static WORD_IM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -49557,7 +91976,7 @@ static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_IMC_NODE), None, Some(&WORD_IME_NODE), - None, + Some(&WORD_IMF_NODE), Some(&WORD_IMG_NODE), None, Some(&WORD_IMI_NODE), @@ -49566,7 +91985,7 @@ static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_IML_NODE), Some(&WORD_IMM_NODE), None, - None, + Some(&WORD_IMO_NODE), Some(&WORD_IMP_NODE), None, Some(&WORD_IMR_NODE), @@ -49601,6 +92020,7 @@ static WORD_IMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -49610,6 +92030,7 @@ pub static WORD_IMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("povised"), ], values: &[ + &["improvement"], &["improve"], &["improved"], &["improvement"], @@ -49629,20 +92050,20 @@ static WORD_IMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_IMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_IMPA_NODE), None, - None, + Some(&WORD_IMPC_NODE), None, Some(&WORD_IMPE_NODE), None, None, None, - None, + Some(&WORD_IMPI_NODE), None, None, Some(&WORD_IMPL_NODE), None, None, Some(&WORD_IMPO_NODE), - None, + Some(&WORD_IMPP_NODE), None, Some(&WORD_IMPR_NODE), None, @@ -49669,6 +92090,7 @@ pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("sle"), dictgen::InsensitiveStr::Ascii("sles"), dictgen::InsensitiveStr::Ascii("slive"), + dictgen::InsensitiveStr::Ascii("t"), ], values: &[ &["impulse"], @@ -49678,84 +92100,152 @@ pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["impulse"], &["impulses"], &["impulsive"], + &["input"], ], - range: 3..=7, + range: 1..=7, }; static WORD_IMPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_IMPR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_IMPR_CHILDREN), value: None, }; -pub static WORD_IMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("actial"), - dictgen::InsensitiveStr::Ascii("acticle"), - dictgen::InsensitiveStr::Ascii("eative"), - dictgen::InsensitiveStr::Ascii("efect"), - dictgen::InsensitiveStr::Ascii("efection"), - dictgen::InsensitiveStr::Ascii("efections"), - dictgen::InsensitiveStr::Ascii("esison"), - dictgen::InsensitiveStr::Ascii("esonating"), - dictgen::InsensitiveStr::Ascii("essario"), - dictgen::InsensitiveStr::Ascii("essin"), - dictgen::InsensitiveStr::Ascii("essoin"), - dictgen::InsensitiveStr::Ascii("essons"), - dictgen::InsensitiveStr::Ascii("esssion"), - dictgen::InsensitiveStr::Ascii("ioned"), - dictgen::InsensitiveStr::Ascii("isonent"), - dictgen::InsensitiveStr::Ascii("isonned"), - dictgen::InsensitiveStr::Ascii("obabe"), - dictgen::InsensitiveStr::Ascii("obabil"), - dictgen::InsensitiveStr::Ascii("obabile"), - dictgen::InsensitiveStr::Ascii("obible"), - dictgen::InsensitiveStr::Ascii("opable"), - dictgen::InsensitiveStr::Ascii("opre"), - dictgen::InsensitiveStr::Ascii("osined"), - dictgen::InsensitiveStr::Ascii("osoned"), - dictgen::InsensitiveStr::Ascii("osonment"), - dictgen::InsensitiveStr::Ascii("otantly"), - dictgen::InsensitiveStr::Ascii("oted"), - dictgen::InsensitiveStr::Ascii("ovemnt"), - dictgen::InsensitiveStr::Ascii("ovemnts"), - dictgen::InsensitiveStr::Ascii("ovents"), - dictgen::InsensitiveStr::Ascii("ovie"), - dictgen::InsensitiveStr::Ascii("oviserad"), - dictgen::InsensitiveStr::Ascii("ovished"), - dictgen::InsensitiveStr::Ascii("ovision"), - dictgen::InsensitiveStr::Ascii("ovized"), + 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("sioned"), + 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("tant"), + dictgen::InsensitiveStr::Ascii("tantly"), + dictgen::InsensitiveStr::Ascii("ted"), + 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: &[ - &["impractical"], - &["impractical"], - &["imperative"], - &["imperfect"], - &["imperfections"], - &["imperfections"], - &["impressions"], - &["impersonating"], - &["impresario"], - &["impressions"], - &["impressions"], - &["impressions"], - &["impressions"], - &["imprisoned"], - &["imprisonment"], - &["imprisoned"], &["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"], + &["important"], &["importantly"], &["imported"], &["improvement"], + &["improvement"], + &["improvements"], + &["improvements"], + &["improvement"], &["improvements"], &["improves"], &["improvised"], @@ -49763,10 +92253,103 @@ pub static WORD_IMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["improvised"], &["improvisation"], &["improvised"], + &["improvement"], + &["improvements"], + &["improvement"], &["improvements"], - &["imprisoned"], ], - range: 4..=9, + range: 2..=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"), + ], + values: &[ + &["imperative"], + &["imperfect"], + &["imperfections"], + &["imperfections"], + &["implemented"], + &["impress"], + &["impressions"], + &["impressive"], + &["impersonating"], + &["impresario"], + &["impressions"], + &["impressions"], + &["impressions"], + &["impressions"], + ], + 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 { @@ -49778,19 +92361,30 @@ pub static WORD_IMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("lde"), dictgen::InsensitiveStr::Ascii("rbable"), + dictgen::InsensitiveStr::Ascii("ring"), + dictgen::InsensitiveStr::Ascii("rove"), + dictgen::InsensitiveStr::Ascii("roved"), + dictgen::InsensitiveStr::Ascii("rovement"), + dictgen::InsensitiveStr::Ascii("rovements"), + dictgen::InsensitiveStr::Ascii("roves"), + dictgen::InsensitiveStr::Ascii("roving"), dictgen::InsensitiveStr::Ascii("rper"), dictgen::InsensitiveStr::Ascii("rtamt"), dictgen::InsensitiveStr::Ascii("rtanly"), dictgen::InsensitiveStr::Ascii("rtantce"), dictgen::InsensitiveStr::Ascii("rtanty"), dictgen::InsensitiveStr::Ascii("rtas"), + dictgen::InsensitiveStr::Ascii("rtat"), dictgen::InsensitiveStr::Ascii("rtd"), dictgen::InsensitiveStr::Ascii("rten"), dictgen::InsensitiveStr::Ascii("rtence"), dictgen::InsensitiveStr::Ascii("rtend"), + dictgen::InsensitiveStr::Ascii("rtent"), dictgen::InsensitiveStr::Ascii("rtently"), dictgen::InsensitiveStr::Ascii("rterad"), dictgen::InsensitiveStr::Ascii("rtes"), + dictgen::InsensitiveStr::Ascii("rtnt"), + dictgen::InsensitiveStr::Ascii("rv"), dictgen::InsensitiveStr::Ascii("rve"), dictgen::InsensitiveStr::Ascii("rved"), dictgen::InsensitiveStr::Ascii("rvement"), @@ -49798,6 +92392,8 @@ pub static WORD_IMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("rves"), dictgen::InsensitiveStr::Ascii("rving"), dictgen::InsensitiveStr::Ascii("rvised"), + dictgen::InsensitiveStr::Ascii("rvment"), + dictgen::InsensitiveStr::Ascii("sible"), dictgen::InsensitiveStr::Ascii("ssable"), dictgen::InsensitiveStr::Ascii("ssbily"), dictgen::InsensitiveStr::Ascii("ssibal"), @@ -49807,32 +92403,53 @@ pub static WORD_IMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ssibillity"), dictgen::InsensitiveStr::Ascii("ssibilty"), dictgen::InsensitiveStr::Ascii("ssibily"), + dictgen::InsensitiveStr::Ascii("ssiblble"), dictgen::InsensitiveStr::Ascii("ssiblely"), dictgen::InsensitiveStr::Ascii("ssibley"), dictgen::InsensitiveStr::Ascii("ssiblity"), dictgen::InsensitiveStr::Ascii("ssiblly"), dictgen::InsensitiveStr::Ascii("ssibry"), dictgen::InsensitiveStr::Ascii("ssibul"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("tr"), + dictgen::InsensitiveStr::Ascii("trt"), + dictgen::InsensitiveStr::Ascii("ve"), + dictgen::InsensitiveStr::Ascii("ved"), + dictgen::InsensitiveStr::Ascii("vement"), + dictgen::InsensitiveStr::Ascii("vements"), dictgen::InsensitiveStr::Ascii("verised"), dictgen::InsensitiveStr::Ascii("vershied"), dictgen::InsensitiveStr::Ascii("versihed"), + dictgen::InsensitiveStr::Ascii("ves"), + dictgen::InsensitiveStr::Ascii("ving"), ], values: &[ &["implode"], &["improbable"], + &["importing"], + &["improve"], + &["improved"], + &["improvement"], + &["improvements"], + &["improves"], + &["improving"], &["improper"], &["important"], &["importantly"], &["importance"], &["importantly"], &["imports"], + &["important"], &["imported"], &["importance"], &["importance"], &["imported"], + &["important"], &["importantly"], &["imported"], &["imports"], + &["important"], + &["improve", "improv"], &["improve"], &["improved"], &["improvement"], @@ -49840,6 +92457,8 @@ pub static WORD_IMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["improves"], &["improving"], &["improvised"], + &["improvement"], + &["impossible"], &["impossible"], &["impossibly"], &["impossibly"], @@ -49849,118 +92468,175 @@ pub static WORD_IMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["impossibility"], &["impossibility"], &["impossibly"], + &["impossible"], &["impossibly"], &["impossibly"], &["impossibly"], &["impossibly"], &["impossibly"], &["impossibly"], + &["import"], + &["import", "importer"], + &["import", "imported", "importer"], + &["improve"], + &["improved"], + &["improvement"], + &["improvements"], &["impoverished"], &["impoverished"], &["impoverished"], + &["improves"], + &["improving"], + ], + range: 1..=10, +}; + +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_IMPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_IMPL_CHILDREN), +static WORD_IMPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_IMPLI_CHILDREN), value: None, }; -pub static WORD_IMPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_IMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("amenting"), - dictgen::InsensitiveStr::Ascii("aments"), - dictgen::InsensitiveStr::Ascii("antase"), - dictgen::InsensitiveStr::Ascii("antes"), - dictgen::InsensitiveStr::Ascii("ausable"), - dictgen::InsensitiveStr::Ascii("ausbile"), - dictgen::InsensitiveStr::Ascii("ausble"), - dictgen::InsensitiveStr::Ascii("ausibe"), - dictgen::InsensitiveStr::Ascii("ausibile"), - dictgen::InsensitiveStr::Ascii("ecations"), - dictgen::InsensitiveStr::Ascii("emenet"), - dictgen::InsensitiveStr::Ascii("ementacion"), - dictgen::InsensitiveStr::Ascii("ementaciones"), - dictgen::InsensitiveStr::Ascii("ementaion"), - dictgen::InsensitiveStr::Ascii("ementaiton"), - dictgen::InsensitiveStr::Ascii("ementaitons"), - dictgen::InsensitiveStr::Ascii("ementas"), - dictgen::InsensitiveStr::Ascii("ementase"), - dictgen::InsensitiveStr::Ascii("ementasi"), - dictgen::InsensitiveStr::Ascii("ementatin"), - dictgen::InsensitiveStr::Ascii("ementating"), - dictgen::InsensitiveStr::Ascii("ementatino"), - dictgen::InsensitiveStr::Ascii("ementationen"), - dictgen::InsensitiveStr::Ascii("ementationer"), - dictgen::InsensitiveStr::Ascii("ementato"), - dictgen::InsensitiveStr::Ascii("ementes"), - dictgen::InsensitiveStr::Ascii("ementig"), - dictgen::InsensitiveStr::Ascii("ementos"), - dictgen::InsensitiveStr::Ascii("emet"), - dictgen::InsensitiveStr::Ascii("emetnation"), - dictgen::InsensitiveStr::Ascii("entation"), - dictgen::InsensitiveStr::Ascii("icacion"), - dictgen::InsensitiveStr::Ascii("icati"), - dictgen::InsensitiveStr::Ascii("icatia"), - dictgen::InsensitiveStr::Ascii("icatie"), - dictgen::InsensitiveStr::Ascii("icatii"), - dictgen::InsensitiveStr::Ascii("icatons"), - dictgen::InsensitiveStr::Ascii("icetly"), - dictgen::InsensitiveStr::Ascii("iciet"), - dictgen::InsensitiveStr::Ascii("iciete"), - dictgen::InsensitiveStr::Ascii("icilty"), - dictgen::InsensitiveStr::Ascii("icitely"), - dictgen::InsensitiveStr::Ascii("icitily"), - dictgen::InsensitiveStr::Ascii("icity"), - dictgen::InsensitiveStr::Ascii("ict"), - dictgen::InsensitiveStr::Ascii("ikation"), - dictgen::InsensitiveStr::Ascii("imenation"), - dictgen::InsensitiveStr::Ascii("iment"), - dictgen::InsensitiveStr::Ascii("imentation"), - dictgen::InsensitiveStr::Ascii("imentations"), - dictgen::InsensitiveStr::Ascii("imented"), - dictgen::InsensitiveStr::Ascii("imenting"), - dictgen::InsensitiveStr::Ascii("iments"), - dictgen::InsensitiveStr::Ascii("oed"), - dictgen::InsensitiveStr::Ascii("osed"), - dictgen::InsensitiveStr::Ascii("oys"), - dictgen::InsensitiveStr::Ascii("use"), - dictgen::InsensitiveStr::Ascii("uses"), - dictgen::InsensitiveStr::Ascii("usive"), + 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("menation"), + dictgen::InsensitiveStr::Ascii("ment"), + 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: &[ - &["implementing"], - &["implements"], - &["implants"], - &["implants"], - &["implausible"], - &["implausible"], - &["implausible"], - &["implausible"], - &["implausible"], - &["implications"], - &["implements"], - &["implementation"], - &["implementations"], - &["implementation"], - &["implementation"], - &["implementations"], - &["implements"], - &["implements"], - &["implements"], - &["implementations"], - &["implementation"], - &["implementations"], - &["implementations"], - &["implementations"], - &["implementation"], - &["implements"], - &["implementing"], - &["implements"], - &["implements"], - &["implementations"], - &["implementation"], &["implication"], &["implicit"], &["implicit"], @@ -49971,10 +92647,13 @@ pub static WORD_IMPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["implicit"], &["implicit"], &["implicitly"], + &["implicit", "implicitly"], + &["implicitly"], &["implicitly"], &["implicitly"], &["implicitly"], &["implicit"], + &["implicitly"], &["implication"], &["implementation"], &["implement"], @@ -49982,15 +92661,487 @@ pub static WORD_IMPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["implementations"], &["implemented"], &["implementing"], + &["implementation"], + &["implementations"], + &["implementor"], &["implements"], - &["implode"], - &["implode"], - &["employs"], - &["impulse"], - &["impulses"], - &["impulsive"], ], - range: 3..=12, + 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, + None, + 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: None, +}; + +pub static WORD_IMPLET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("ment")], + values: &[&["implement"]], + range: 4..=4, +}; + +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: None, +}; + +pub static WORD_IMPLEMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = + dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("entation"), + ], + values: &[&["implementation"], &["implementation"]], + range: 5..=8, + }; + +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("ing"), + dictgen::InsensitiveStr::Ascii("nation"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[ + &["implementation"], + &["implementations"], + &["implemented"], + &["implementing"], + &["implementations", "implementation"], + &["implements"], + ], + range: 1..=6, + }; + +static WORD_IMPLEMEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEN_CHILDREN), + value: Some(&["implement"]), +}; + +pub static WORD_IMPLEMEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = + dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("atation"), + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("ationa"), + dictgen::InsensitiveStr::Ascii("ationd"), + dictgen::InsensitiveStr::Ascii("ations"), + dictgen::InsensitiveStr::Ascii("cted"), + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("ds"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("et"), + dictgen::InsensitiveStr::Ascii("etaion"), + dictgen::InsensitiveStr::Ascii("etaions"), + dictgen::InsensitiveStr::Ascii("etation"), + dictgen::InsensitiveStr::Ascii("etations"), + dictgen::InsensitiveStr::Ascii("etd"), + dictgen::InsensitiveStr::Ascii("eted"), + dictgen::InsensitiveStr::Ascii("eter"), + dictgen::InsensitiveStr::Ascii("eting"), + dictgen::InsensitiveStr::Ascii("etions"), + dictgen::InsensitiveStr::Ascii("ets"), + dictgen::InsensitiveStr::Ascii("rt"), + dictgen::InsensitiveStr::Ascii("tacion"), + dictgen::InsensitiveStr::Ascii("taciones"), + dictgen::InsensitiveStr::Ascii("taed"), + dictgen::InsensitiveStr::Ascii("taion"), + dictgen::InsensitiveStr::Ascii("taions"), + dictgen::InsensitiveStr::Ascii("taiton"), + dictgen::InsensitiveStr::Ascii("taitons"), + dictgen::InsensitiveStr::Ascii("tantions"), + dictgen::InsensitiveStr::Ascii("tas"), + dictgen::InsensitiveStr::Ascii("tase"), + dictgen::InsensitiveStr::Ascii("tasi"), + dictgen::InsensitiveStr::Ascii("tastion"), + dictgen::InsensitiveStr::Ascii("tataion"), + dictgen::InsensitiveStr::Ascii("tatation"), + dictgen::InsensitiveStr::Ascii("tated"), + dictgen::InsensitiveStr::Ascii("tates"), + dictgen::InsensitiveStr::Ascii("tatin"), + dictgen::InsensitiveStr::Ascii("tating"), + dictgen::InsensitiveStr::Ascii("tatino"), + dictgen::InsensitiveStr::Ascii("tatins"), + dictgen::InsensitiveStr::Ascii("tationen"), + dictgen::InsensitiveStr::Ascii("tationer"), + dictgen::InsensitiveStr::Ascii("tatition"), + dictgen::InsensitiveStr::Ascii("tato"), + dictgen::InsensitiveStr::Ascii("tatoin"), + dictgen::InsensitiveStr::Ascii("tatoins"), + dictgen::InsensitiveStr::Ascii("tatoion"), + dictgen::InsensitiveStr::Ascii("taton"), + dictgen::InsensitiveStr::Ascii("tator"), + dictgen::InsensitiveStr::Ascii("tators"), + dictgen::InsensitiveStr::Ascii("tattion"), + dictgen::InsensitiveStr::Ascii("td"), + dictgen::InsensitiveStr::Ascii("te"), + dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("tet"), + dictgen::InsensitiveStr::Ascii("tig"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tos"), + dictgen::InsensitiveStr::Ascii("ttaion"), + ], + values: &[ + &["implementation"], + &["implementation"], + &["implementation"], + &["implementation"], + &["implementations"], + &["implemented"], + &["implement"], + &["implements"], + &["implemented"], + &["implements", "implement"], + &["implementation"], + &["implementations"], + &["implementation"], + &["implementations"], + &["implemented"], + &["implemented"], + &["implementer"], + &["implementing"], + &["implementations"], + &["implements"], + &["implement"], + &["implementation"], + &["implementations"], + &["implemented"], + &["implementation"], + &["implementations"], + &["implementation"], + &["implementations"], + &["implementations"], + &["implements"], + &["implements"], + &["implements"], + &["implementation"], + &["implementation"], + &["implementation"], + &["implemented"], + &["implements"], + &["implementations", "implementation", "implementing"], + &["implementation", "implementing"], + &["implementations"], + &["implementations"], + &["implementations"], + &["implementations"], + &["implementation"], + &["implementation"], + &["implementation"], + &["implementations"], + &["implementation"], + &["implementation"], + &["implementer"], + &["implementers"], + &["implementation"], + &["implemented"], + &["implement", "implemented"], + &["implements"], + &["implemented"], + &["implementing"], + &["implementation"], + &["implements"], + &["implementation"], + ], + range: 1..=8, + }; + +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_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")], + values: &[&["implicit"]], + range: 2..=2, +}; + +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 { @@ -50005,8 +93156,27 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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"), @@ -50014,6 +93184,7 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -50035,8 +93206,27 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["impeccable"], &["impeccable"], &["impedance"], + &["impede"], + &["implement"], + &["implementation"], + &["implemented"], + &["implementing"], + &["implements"], + &["implementation"], + &["implement"], &["implementations"], &["implements"], + &["implement"], + &["implementation"], + &["implementations"], + &["implemented"], + &["implementation"], + &["implementations"], + &["implemented"], + &["implementing"], + &["implementing"], + &["implementer"], + &["implements"], &["imperialist"], &["imperative"], &["imperialist"], @@ -50044,6 +93234,7 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["imperfections"], &["imperfections"], &["imperfect"], + &["imperial"], &["imperialist"], &["imperialism"], &["imperialism"], @@ -50059,7 +93250,23 @@ pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["impersonating"], &["impersonating"], ], - range: 4..=12, + 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 { @@ -50087,93 +93294,197 @@ pub static WORD_IMPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic range: 4..=6, }; -static WORD_IMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_IMM_CHILDREN), +static WORD_IMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_IMO_CHILDREN), value: None, }; -pub static WORD_IMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_IMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aturaty"), - dictgen::InsensitiveStr::Ascii("atureity"), - dictgen::InsensitiveStr::Ascii("aturety"), - dictgen::InsensitiveStr::Ascii("boile"), - dictgen::InsensitiveStr::Ascii("edeately"), - dictgen::InsensitiveStr::Ascii("edeatly"), - dictgen::InsensitiveStr::Ascii("ediantly"), - dictgen::InsensitiveStr::Ascii("ediatelly"), - dictgen::InsensitiveStr::Ascii("ediatley"), - dictgen::InsensitiveStr::Ascii("ediatly"), - dictgen::InsensitiveStr::Ascii("edietely"), - dictgen::InsensitiveStr::Ascii("edietly"), - dictgen::InsensitiveStr::Ascii("enint"), - dictgen::InsensitiveStr::Ascii("enseley"), - dictgen::InsensitiveStr::Ascii("ensley"), - dictgen::InsensitiveStr::Ascii("erisve"), - dictgen::InsensitiveStr::Ascii("ersie"), - dictgen::InsensitiveStr::Ascii("ersve"), - dictgen::InsensitiveStr::Ascii("esnely"), - dictgen::InsensitiveStr::Ascii("idately"), - dictgen::InsensitiveStr::Ascii("ideately"), - dictgen::InsensitiveStr::Ascii("idiate"), - dictgen::InsensitiveStr::Ascii("idiately"), - dictgen::InsensitiveStr::Ascii("igraiton"), - dictgen::InsensitiveStr::Ascii("igrantes"), - dictgen::InsensitiveStr::Ascii("igranti"), - dictgen::InsensitiveStr::Ascii("igrato"), - dictgen::InsensitiveStr::Ascii("igrents"), - dictgen::InsensitiveStr::Ascii("inet"), - dictgen::InsensitiveStr::Ascii("itate"), - dictgen::InsensitiveStr::Ascii("itated"), - dictgen::InsensitiveStr::Ascii("itating"), - dictgen::InsensitiveStr::Ascii("itator"), - dictgen::InsensitiveStr::Ascii("obilie"), - dictgen::InsensitiveStr::Ascii("obilien"), - dictgen::InsensitiveStr::Ascii("obilier"), - dictgen::InsensitiveStr::Ascii("obille"), - dictgen::InsensitiveStr::Ascii("obilze"), - dictgen::InsensitiveStr::Ascii("obilzed"), - dictgen::InsensitiveStr::Ascii("obilzer"), - dictgen::InsensitiveStr::Ascii("obilzes"), - dictgen::InsensitiveStr::Ascii("oblie"), - dictgen::InsensitiveStr::Ascii("oratlity"), - dictgen::InsensitiveStr::Ascii("ortailty"), - dictgen::InsensitiveStr::Ascii("ortales"), - dictgen::InsensitiveStr::Ascii("ortalis"), - dictgen::InsensitiveStr::Ascii("ortalisy"), - dictgen::InsensitiveStr::Ascii("ortaliy"), - dictgen::InsensitiveStr::Ascii("ortallity"), - dictgen::InsensitiveStr::Ascii("ortalls"), - dictgen::InsensitiveStr::Ascii("ortalty"), - dictgen::InsensitiveStr::Ascii("ortaly"), - dictgen::InsensitiveStr::Ascii("ortas"), - dictgen::InsensitiveStr::Ascii("serive"), - dictgen::InsensitiveStr::Ascii("unosupressant"), + 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")], + values: &[&["immersive"]], + range: 5..=5, +}; + +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: &[ - &["immaturity"], - &["immaturity"], - &["immaturity"], &["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"], - &["immediately"], - &["immediately"], - &["immediately"], - &["immediately"], - &["immediately"], - &["imminent"], - &["immensely"], - &["immensely"], - &["immersive"], - &["immerse"], - &["immerse"], - &["immensely"], - &["immediately"], - &["immediately"], &["immediate"], &["immediately"], + &["immediately"], + &["immediately"], &["immigration"], &["immigrants"], &["immigration"], @@ -50184,30 +93495,119 @@ pub static WORD_IMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["imitated"], &["imitating"], &["imitator"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immobile"], - &["immortality"], - &["immortality"], - &["immortals"], - &["immortals"], - &["immortals"], - &["immortality"], - &["immortality"], - &["immortals"], - &["immortality"], - &["immortality"], - &["immortals"], - &["immersive"], - &["immunosuppressant"], ], - range: 4..=13, + 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("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("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"], + &["immediately"], + &["immediately"], + &["immediately"], + &["immediately"], + &["immediately"], + &["immediately"], + &["immediate", "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 { @@ -50216,9 +93616,37 @@ static WORD_IML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_IML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("pementation")], - values: &[&["implementations"]], - range: 11..=11, + 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 { @@ -50228,13 +93656,24 @@ static WORD_IMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["emigrant"], &["emigrated"], &["emigration"], &["eminent"]], - range: 4..=7, + 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 { @@ -50243,9 +93682,23 @@ static WORD_IMG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_IMG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rants")], - values: &[&["migrants"]], - range: 5..=5, + 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 { @@ -50255,11 +93708,23 @@ static WORD_IME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["immense"], &["inexperience"]], + values: &[ + &["immediately"], + &["immediately"], + &["immediate"], + &["immediately"], + &["immediately"], + &["immense"], + &["inexperience"], + ], range: 3..=9, }; @@ -50270,18 +93735,24 @@ static WORD_IMC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 7..=13, + range: 5..=13, }; static WORD_IMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -50296,6 +93767,9 @@ pub static WORD_IMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("alancers"), dictgen::InsensitiveStr::Ascii("alenced"), dictgen::InsensitiveStr::Ascii("alences"), + dictgen::InsensitiveStr::Ascii("aress"), + dictgen::InsensitiveStr::Ascii("lance"), + dictgen::InsensitiveStr::Ascii("rase"), ], values: &[ &["imbalanced"], @@ -50303,8 +93777,11 @@ pub static WORD_IMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["imbalances"], &["imbalanced"], &["imbalances"], + &["embarrass"], + &["imbalance"], + &["embrace"], ], - range: 7..=8, + range: 4..=8, }; static WORD_IMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -50319,6 +93796,7 @@ pub static WORD_IMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -50330,7 +93808,11 @@ pub static WORD_IMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ginitave"), dictgen::InsensitiveStr::Ascii("ginitve"), 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"), ], @@ -50340,6 +93822,7 @@ pub static WORD_IMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["imaginative"], &["imaginative"], &["imaginary"], + &["image"], &["imagine"], &["imagination"], &["imaginative"], @@ -50347,11 +93830,15 @@ pub static WORD_IMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["imagination"], &["imagination"], &["imagination"], - &["imaginary"], + &["imaginary", "imagery"], &["imaginative"], &["imaginative"], - &["eminent"], + &["eminent", "imminent"], + &["impact"], + &["impacted"], + &["impacting"], &["impacts"], + &["image"], &["impaired"], &["impatient"], ], @@ -50364,15 +93851,15 @@ static WORD_IL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; 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, - None, - None, - None, + Some(&WORD_ILI_NODE), None, None, Some(&WORD_ILL_NODE), @@ -50384,7 +93871,7 @@ static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_ILT_NODE), - None, + Some(&WORD_ILU_NODE), None, None, None, @@ -50392,6 +93879,35 @@ static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> 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, @@ -50437,7 +93953,7 @@ static WORD_ILL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_ILLE_NODE), None, - None, + Some(&WORD_ILLG_NODE), None, Some(&WORD_ILLI_NODE), None, @@ -50500,6 +94016,7 @@ pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -50545,6 +94062,7 @@ pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["illustrator"], &["illustrate"], &["illustrate"], + &["illustration"], &["illustrator"], &["illustrate"], &["illustrate"], @@ -50595,7 +94113,9 @@ static WORD_ILLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -50610,6 +94130,8 @@ pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["illegal"], + &["illegal"], + &["illegitimate"], &["illegitimate"], &["illegitimate"], &["illuminati"], @@ -50617,7 +94139,7 @@ pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["illinois"], &["illinois"], &["illinois"], - &["illiterate"], + &["illiterate", "illustrate"], &["illustration"], &["illustrations"], &["illiterate"], @@ -50626,6 +94148,17 @@ pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -50677,15 +94210,70 @@ pub static WORD_ILLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), + ], + values: &[&["if"], &["immune"], &["include"]], + range: 1..=6, +}; + 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")], - values: &[&["ithaca"]], - range: 3..=3, + 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 { @@ -50696,11 +94284,140 @@ static WORD_IG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_IG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("nitin"), + dictgen::InsensitiveStr::Ascii("noded"), + dictgen::InsensitiveStr::Ascii("nonre"), + dictgen::InsensitiveStr::Ascii("nora"), dictgen::InsensitiveStr::Ascii("norat"), + dictgen::InsensitiveStr::Ascii("nord"), + dictgen::InsensitiveStr::Ascii("noreing"), + dictgen::InsensitiveStr::Ascii("norence"), + dictgen::InsensitiveStr::Ascii("norgable"), + dictgen::InsensitiveStr::Ascii("norgd"), + dictgen::InsensitiveStr::Ascii("norge"), + dictgen::InsensitiveStr::Ascii("norged"), + dictgen::InsensitiveStr::Ascii("norgg"), + dictgen::InsensitiveStr::Ascii("norgig"), + dictgen::InsensitiveStr::Ascii("norging"), + dictgen::InsensitiveStr::Ascii("norgs"), + dictgen::InsensitiveStr::Ascii("normable"), + dictgen::InsensitiveStr::Ascii("normd"), + dictgen::InsensitiveStr::Ascii("norme"), + dictgen::InsensitiveStr::Ascii("normed"), + dictgen::InsensitiveStr::Ascii("normg"), + dictgen::InsensitiveStr::Ascii("normig"), + dictgen::InsensitiveStr::Ascii("norming"), + dictgen::InsensitiveStr::Ascii("norms"), + dictgen::InsensitiveStr::Ascii("nornable"), dictgen::InsensitiveStr::Ascii("nornace"), + dictgen::InsensitiveStr::Ascii("nornd"), + dictgen::InsensitiveStr::Ascii("norne"), + dictgen::InsensitiveStr::Ascii("norned"), + dictgen::InsensitiveStr::Ascii("norng"), + dictgen::InsensitiveStr::Ascii("nornig"), + dictgen::InsensitiveStr::Ascii("norning"), + dictgen::InsensitiveStr::Ascii("norns"), + dictgen::InsensitiveStr::Ascii("norrable"), + dictgen::InsensitiveStr::Ascii("norrd"), + dictgen::InsensitiveStr::Ascii("norre"), + dictgen::InsensitiveStr::Ascii("norred"), + dictgen::InsensitiveStr::Ascii("norrg"), + dictgen::InsensitiveStr::Ascii("norrig"), + dictgen::InsensitiveStr::Ascii("norring"), + dictgen::InsensitiveStr::Ascii("norrs"), + dictgen::InsensitiveStr::Ascii("nors"), + dictgen::InsensitiveStr::Ascii("nortable"), + dictgen::InsensitiveStr::Ascii("nortd"), + dictgen::InsensitiveStr::Ascii("norte"), + dictgen::InsensitiveStr::Ascii("norted"), + dictgen::InsensitiveStr::Ascii("nortg"), + dictgen::InsensitiveStr::Ascii("nortig"), + dictgen::InsensitiveStr::Ascii("norting"), + dictgen::InsensitiveStr::Ascii("norts"), + dictgen::InsensitiveStr::Ascii("nory"), + dictgen::InsensitiveStr::Ascii("nroed"), + dictgen::InsensitiveStr::Ascii("nroing"), + dictgen::InsensitiveStr::Ascii("oned"), + dictgen::InsensitiveStr::Ascii("onorando"), + dictgen::InsensitiveStr::Ascii("onore"), + dictgen::InsensitiveStr::Ascii("ore"), + dictgen::InsensitiveStr::Ascii("ored"), + dictgen::InsensitiveStr::Ascii("ores"), + dictgen::InsensitiveStr::Ascii("oring"), ], - values: &[&["ignition"], &["ignorant"], &["ignorance"]], - range: 5..=7, + values: &[ + &["ignition"], + &["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"], + &["ignored"], + &["ignorando"], + &["ignore"], + &["ignore"], + &["ignored"], + &["ignores"], + &["ignoring"], + ], + range: 3..=8, +}; + +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("self")], + values: &[&["itself"]], + range: 4..=4, }; static WORD_IE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -50709,72 +94426,326 @@ static WORD_IE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_IE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rland")], - values: &[&["ireland"]], + 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::Flat(&WORD_ID_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ID_CHILDREN), value: None, }; -pub static WORD_ID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, +]; + +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("aeidae"), - dictgen::InsensitiveStr::Ascii("aes"), - dictgen::InsensitiveStr::Ascii("ealisim"), - dictgen::InsensitiveStr::Ascii("ealisitc"), - dictgen::InsensitiveStr::Ascii("ealisitic"), - dictgen::InsensitiveStr::Ascii("ealistc"), - dictgen::InsensitiveStr::Ascii("ealistisch"), - dictgen::InsensitiveStr::Ascii("ealogies"), - dictgen::InsensitiveStr::Ascii("ealogy"), - dictgen::InsensitiveStr::Ascii("ealsim"), - dictgen::InsensitiveStr::Ascii("enfity"), - dictgen::InsensitiveStr::Ascii("enitfy"), - dictgen::InsensitiveStr::Ascii("enticial"), - dictgen::InsensitiveStr::Ascii("entifible"), - dictgen::InsensitiveStr::Ascii("entificacion"), - dictgen::InsensitiveStr::Ascii("entificaiton"), - dictgen::InsensitiveStr::Ascii("entificativo"), - dictgen::InsensitiveStr::Ascii("entificato"), - dictgen::InsensitiveStr::Ascii("entificaton"), - dictgen::InsensitiveStr::Ascii("entifierad"), - dictgen::InsensitiveStr::Ascii("entifieras"), - dictgen::InsensitiveStr::Ascii("entifikation"), - dictgen::InsensitiveStr::Ascii("entifiy"), - dictgen::InsensitiveStr::Ascii("entifyable"), - dictgen::InsensitiveStr::Ascii("entifyed"), - dictgen::InsensitiveStr::Ascii("entite"), - dictgen::InsensitiveStr::Ascii("entitets"), - dictgen::InsensitiveStr::Ascii("entitites"), - dictgen::InsensitiveStr::Ascii("entitties"), - dictgen::InsensitiveStr::Ascii("eolagies"), - dictgen::InsensitiveStr::Ascii("eoligically"), - dictgen::InsensitiveStr::Ascii("eoligies"), - dictgen::InsensitiveStr::Ascii("eologe"), - dictgen::InsensitiveStr::Ascii("eologias"), - dictgen::InsensitiveStr::Ascii("eologicaly"), - dictgen::InsensitiveStr::Ascii("eologice"), - dictgen::InsensitiveStr::Ascii("eologiers"), - dictgen::InsensitiveStr::Ascii("eologije"), - dictgen::InsensitiveStr::Ascii("eologins"), - dictgen::InsensitiveStr::Ascii("eologis"), - dictgen::InsensitiveStr::Ascii("eologisen"), - dictgen::InsensitiveStr::Ascii("eologiset"), - dictgen::InsensitiveStr::Ascii("eologisk"), - dictgen::InsensitiveStr::Ascii("eologiske"), - dictgen::InsensitiveStr::Ascii("eolouges"), - dictgen::InsensitiveStr::Ascii("eosyncratic"), - dictgen::InsensitiveStr::Ascii("esa"), - dictgen::InsensitiveStr::Ascii("iologically"), - dictgen::InsensitiveStr::Ascii("iosynchracies"), - dictgen::InsensitiveStr::Ascii("iosyncracy"), + 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("osynchracies"), + 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"], + &["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, + None, + None, + None, + Some(&WORD_IDEL_NODE), + None, + Some(&WORD_IDEN_NODE), + Some(&WORD_IDEO_NODE), + None, + 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("ifies")], + values: &[&["identifies"]], + range: 5..=5, +}; + +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_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("syncracies"), + dictgen::InsensitiveStr::Ascii("syncratic"), + ], + values: &[ + &["ideologies"], + &["ideologically"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologically"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideologies"], + &["ideosyncrasies"], + &["idiosyncratic"], + ], + range: 4..=10, +}; + +static WORD_IDEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_IDEN_CHILDREN), + value: None, +}; + +pub static WORD_IDEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("difier"), + dictgen::InsensitiveStr::Ascii("fifier"), + dictgen::InsensitiveStr::Ascii("fity"), + dictgen::InsensitiveStr::Ascii("itfy"), + dictgen::InsensitiveStr::Ascii("itify"), + dictgen::InsensitiveStr::Ascii("tation"), + dictgen::InsensitiveStr::Ascii("tcial"), + dictgen::InsensitiveStr::Ascii("tiable"), + dictgen::InsensitiveStr::Ascii("tial"), + dictgen::InsensitiveStr::Ascii("ticial"), + dictgen::InsensitiveStr::Ascii("tidier"), + dictgen::InsensitiveStr::Ascii("tifaction"), + dictgen::InsensitiveStr::Ascii("tifcation"), + dictgen::InsensitiveStr::Ascii("tifeir"), + dictgen::InsensitiveStr::Ascii("tifeirs"), + dictgen::InsensitiveStr::Ascii("tifer"), + dictgen::InsensitiveStr::Ascii("tifers"), + dictgen::InsensitiveStr::Ascii("tifible"), + dictgen::InsensitiveStr::Ascii("tificable"), + dictgen::InsensitiveStr::Ascii("tificacion"), + dictgen::InsensitiveStr::Ascii("tificaiton"), + dictgen::InsensitiveStr::Ascii("tificativo"), + dictgen::InsensitiveStr::Ascii("tificato"), + dictgen::InsensitiveStr::Ascii("tificaton"), + dictgen::InsensitiveStr::Ascii("tifictaion"), + dictgen::InsensitiveStr::Ascii("tifieer"), + dictgen::InsensitiveStr::Ascii("tifierad"), + dictgen::InsensitiveStr::Ascii("tifieras"), + dictgen::InsensitiveStr::Ascii("tifikation"), + dictgen::InsensitiveStr::Ascii("tifing"), + dictgen::InsensitiveStr::Ascii("tifiy"), + dictgen::InsensitiveStr::Ascii("tifyable"), + dictgen::InsensitiveStr::Ascii("tifyed"), + dictgen::InsensitiveStr::Ascii("tite"), + dictgen::InsensitiveStr::Ascii("titets"), + dictgen::InsensitiveStr::Ascii("titites"), + dictgen::InsensitiveStr::Ascii("titties"), + dictgen::InsensitiveStr::Ascii("tiy"), + dictgen::InsensitiveStr::Ascii("ttation"), + dictgen::InsensitiveStr::Ascii("tties"), + dictgen::InsensitiveStr::Ascii("ttifier"), + dictgen::InsensitiveStr::Ascii("tty"), + ], + values: &[ + &["identifier"], + &["identifier"], + &["identify"], + &["identify"], + &["identify"], + &["indentation"], + &["identical"], + &["identifiable"], + &["identical"], + &["identical"], + &["identifier"], + &["identification"], + &["identification"], + &["identifier"], + &["identifiers"], + &["identifier"], + &["identifiers"], + &["identifiable"], + &["identifiable"], + &["identification"], + &["identification"], + &["identification"], + &["identification"], + &["identification"], + &["identification"], + &["identifier"], + &["identified"], + &["identifies"], + &["identification"], + &["identifying"], + &["identify"], + &["identifiable"], + &["identified"], + &["identities"], + &["identities"], + &["identities"], + &["identities"], + &["identify", "identity"], + &["indentation"], + &["identities"], + &["identifier"], + &["identity"], + ], + range: 3..=10, +}; + +static WORD_IDEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_IDEL_CHILDREN), + value: None, +}; + +pub static WORD_IDEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("ogy")], + values: &[&["ideology"]], + range: 3..=3, +}; + +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: &[ - &["idea"], - &["ideas"], &["idealism"], &["idealistic"], &["idealistic"], @@ -50783,48 +94754,23 @@ pub static WORD_ID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["ideologies"], &["ideology"], &["idealism"], - &["identify"], - &["identify"], - &["identical"], - &["identifiable"], - &["identification"], - &["identification"], - &["identification"], - &["identification"], - &["identification"], - &["identified"], - &["identifies"], - &["identification"], - &["identify"], - &["identifiable"], - &["identified"], - &["identities"], - &["identities"], - &["identities"], - &["identities"], - &["ideologies"], - &["ideologically"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologically"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["ideologies"], - &["idiosyncratic"], - &["ideas"], - &["ideologically"], - &["idiosyncrasies"], - &["idiosyncrasy"], ], - range: 3..=13, + 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 { @@ -50838,18 +94784,24 @@ pub static WORD_IC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("efrong"), dictgen::InsensitiveStr::Ascii("elandinc"), dictgen::InsensitiveStr::Ascii("elings"), + dictgen::InsensitiveStr::Ascii("esickle"), dictgen::InsensitiveStr::Ascii("leandic"), + dictgen::InsensitiveStr::Ascii("luding"), dictgen::InsensitiveStr::Ascii("onclastic"), dictgen::InsensitiveStr::Ascii("ongnito"), + dictgen::InsensitiveStr::Ascii("onifie"), ], values: &[ &["icefrog"], &["icefrog"], &["icelandic"], &["ceilings"], + &["icicle"], &["icelandic"], + &["including"], &["iconoclastic"], &["incognito"], + &["iconify"], ], range: 5..=9, }; @@ -50861,12 +94813,24 @@ static WORD_IB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_IB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("rary"), dictgen::InsensitiveStr::Ascii("uprofein"), dictgen::InsensitiveStr::Ascii("uprofine"), dictgen::InsensitiveStr::Ascii("urpofen"), ], - values: &[&["ibuprofen"], &["ibuprofen"], &["ibuprofen"]], - range: 7..=8, + values: &[&["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 { @@ -50881,18 +94845,18 @@ static WORD_H_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_HD_NODE), Some(&WORD_HE_NODE), None, - None, + Some(&WORD_HG_NODE), None, Some(&WORD_HI_NODE), None, None, None, None, - None, + Some(&WORD_HN_NODE), Some(&WORD_HO_NODE), None, None, - None, + Some(&WORD_HR_NODE), Some(&WORD_HS_NODE), Some(&WORD_HT_NODE), Some(&WORD_HU_NODE), @@ -50913,12 +94877,12 @@ static WORD_HY_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_HYB_NODE), None, Some(&WORD_HYD_NODE), - None, + Some(&WORD_HYE_NODE), None, Some(&WORD_HYG_NODE), None, None, - None, + Some(&WORD_HYJ_NODE), None, None, None, @@ -50989,136 +94953,291 @@ pub static WORD_HYR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_HYP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_HYP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_HYP_CHILDREN), value: None, }; -pub static WORD_HYP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("athetical"), - dictgen::InsensitiveStr::Ascii("athetically"), - dictgen::InsensitiveStr::Ascii("corite"), - dictgen::InsensitiveStr::Ascii("erbel"), - dictgen::InsensitiveStr::Ascii("erbolie"), - dictgen::InsensitiveStr::Ascii("erbollic"), - dictgen::InsensitiveStr::Ascii("erbrophy"), - dictgen::InsensitiveStr::Ascii("erlobic"), - dictgen::InsensitiveStr::Ascii("erlogic"), - dictgen::InsensitiveStr::Ascii("eroble"), - dictgen::InsensitiveStr::Ascii("erthropy"), - dictgen::InsensitiveStr::Ascii("ertorphy"), - dictgen::InsensitiveStr::Ascii("ertrohpy"), - dictgen::InsensitiveStr::Ascii("ertrohy"), - dictgen::InsensitiveStr::Ascii("ertrophey"), - dictgen::InsensitiveStr::Ascii("ertropy"), - dictgen::InsensitiveStr::Ascii("ethetical"), - dictgen::InsensitiveStr::Ascii("ethetically"), - dictgen::InsensitiveStr::Ascii("hotesis"), - dictgen::InsensitiveStr::Ascii("noss"), - dictgen::InsensitiveStr::Ascii("ocracy"), - dictgen::InsensitiveStr::Ascii("ocrasy"), - dictgen::InsensitiveStr::Ascii("ocrates"), - dictgen::InsensitiveStr::Ascii("ocricy"), - dictgen::InsensitiveStr::Ascii("ocriet"), - dictgen::InsensitiveStr::Ascii("ocriscy"), - dictgen::InsensitiveStr::Ascii("ocrises"), - dictgen::InsensitiveStr::Ascii("ocrit"), - dictgen::InsensitiveStr::Ascii("ocritcal"), - dictgen::InsensitiveStr::Ascii("ocritial"), - dictgen::InsensitiveStr::Ascii("ocriticial"), - dictgen::InsensitiveStr::Ascii("ocrities"), - dictgen::InsensitiveStr::Ascii("ocrits"), - dictgen::InsensitiveStr::Ascii("ocritus"), - dictgen::InsensitiveStr::Ascii("ocrticial"), - dictgen::InsensitiveStr::Ascii("ocrties"), - dictgen::InsensitiveStr::Ascii("ocrytes"), - dictgen::InsensitiveStr::Ascii("ocrytical"), - dictgen::InsensitiveStr::Ascii("okrites"), - dictgen::InsensitiveStr::Ascii("onsis"), - dictgen::InsensitiveStr::Ascii("orcite"), - dictgen::InsensitiveStr::Ascii("otehtical"), - dictgen::InsensitiveStr::Ascii("otehtically"), - dictgen::InsensitiveStr::Ascii("otethical"), - dictgen::InsensitiveStr::Ascii("otethically"), - dictgen::InsensitiveStr::Ascii("othecis"), - dictgen::InsensitiveStr::Ascii("otheiss"), - dictgen::InsensitiveStr::Ascii("otherical"), - dictgen::InsensitiveStr::Ascii("othesees"), - dictgen::InsensitiveStr::Ascii("othesies"), - dictgen::InsensitiveStr::Ascii("othess"), - dictgen::InsensitiveStr::Ascii("othesus"), - dictgen::InsensitiveStr::Ascii("otheticaly"), - dictgen::InsensitiveStr::Ascii("otheticly"), - dictgen::InsensitiveStr::Ascii("othises"), - dictgen::InsensitiveStr::Ascii("othisis"), - dictgen::InsensitiveStr::Ascii("othosis"), - dictgen::InsensitiveStr::Ascii("rocisy"), - dictgen::InsensitiveStr::Ascii("rocite"), - dictgen::InsensitiveStr::Ascii("rocites"), + dictgen::InsensitiveStr::Ascii("ervisor"), + dictgen::InsensitiveStr::Ascii("ervisors"), + dictgen::InsensitiveStr::Ascii("isor"), + dictgen::InsensitiveStr::Ascii("isors"), ], values: &[ - &["hypothetical"], - &["hypothetically"], - &["hypocrite"], - &["hyperbole"], - &["hyperbole"], - &["hyperbolic"], - &["hypertrophy"], - &["hyperbolic"], - &["hyperbolic"], - &["hyperbole"], - &["hypertrophy"], - &["hypertrophy"], - &["hypertrophy"], - &["hypertrophy"], - &["hypertrophy"], - &["hypertrophy"], - &["hypothetical"], - &["hypothetically"], - &["hypothesis"], - &["hypnosis"], - &["hypocrisy"], - &["hypocrisy"], - &["hypocrites"], - &["hypocrisy"], - &["hypocrite"], - &["hypocrisy"], - &["hypocrites"], - &["hypocrite"], - &["hypocritical"], - &["hypocritical"], - &["hypocritical"], - &["hypocrite"], - &["hypocrites"], - &["hypocrites"], - &["hypocritical"], - &["hypocrites"], - &["hypocrites"], - &["hypocritical"], - &["hypocrites"], - &["hypnosis"], - &["hypocrite"], - &["hypothetical"], - &["hypothetically"], - &["hypothetical"], - &["hypothetically"], - &["hypothesis"], - &["hypotheses"], - &["hypothetical"], - &["hypotheses"], - &["hypothesis"], - &["hypotheses"], - &["hypotheses"], - &["hypothetically"], - &["hypothetical"], - &["hypotheses"], - &["hypothesis"], - &["hypothesis"], - &["hypocrisy"], - &["hypocrite"], - &["hypocrites"], + &["hypervisor"], + &["hypervisors"], + &["hypervisor"], + &["hypervisors"], ], - range: 4..=11, + 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("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"], + &["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("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"), + ], + values: &[ + &["hyphen"], + &["hyphenate"], + &["hyphenated"], + &["hyphenates"], + &["hyphenating"], + &["hyphenation"], + &["hyphens"], + &["hyperbole"], + &["hyperbole"], + &["hyperbolic"], + &["hyperbole"], + &["hypertrophy"], + &["hyperbolic"], + &["hyperbolic"], + &["hyperbole"], + &["hypertrophy"], + &["hypertrophy"], + &["hypertrophy"], + &["hypertrophy"], + &["hypertrophy"], + &["hypertrophy"], + &["hypervisor"], + &["hypothetical"], + &["hypothetically"], + ], + 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 { @@ -51136,6 +95255,20 @@ pub static WORD_HYO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -51144,11 +95277,35 @@ static WORD_HYG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["hygiene"]], - range: 4..=5, + 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 { @@ -51163,6 +95320,8 @@ pub static WORD_HYD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -51175,6 +95334,8 @@ pub static WORD_HYD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hydraulic"], &["hydration"], &["hydrogen"], + &["hydraulic"], + &["hydraulics"], &["hydrophile"], &["hydrophilic"], &["hydrophobe"], @@ -51191,12 +95352,13 @@ static WORD_HYB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["hybrids"], &["hybrids"], &["hybrids"]], - range: 4..=5, + values: &[&["hibernate"], &["hybrids"], &["hybrids"], &["hybrids"]], + range: 4..=6, }; static WORD_HW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -51224,149 +95386,285 @@ pub static WORD_HV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("ae"), dictgen::InsensitiveStr::Ascii("aing"), + dictgen::InsensitiveStr::Ascii("e"), dictgen::InsensitiveStr::Ascii("ea"), ], - values: &[&["have"], &["having"], &["have"]], - range: 2..=4, + values: &[&["have"], &["having"], &["have"], &["have", "heave"]], + range: 1..=4, }; static WORD_HU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_HU_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_HU_CHILDREN), value: None, }; -pub static WORD_HU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("anted"), - dictgen::InsensitiveStr::Ascii("anting"), - dictgen::InsensitiveStr::Ascii("llucination"), - dictgen::InsensitiveStr::Ascii("llucinations"), - dictgen::InsensitiveStr::Ascii("manaties"), - dictgen::InsensitiveStr::Ascii("maniod"), - dictgen::InsensitiveStr::Ascii("manit"), - dictgen::InsensitiveStr::Ascii("manitarien"), - dictgen::InsensitiveStr::Ascii("manitarion"), - dictgen::InsensitiveStr::Ascii("manitarna"), - dictgen::InsensitiveStr::Ascii("manitary"), - dictgen::InsensitiveStr::Ascii("manitatian"), - dictgen::InsensitiveStr::Ascii("manite"), - dictgen::InsensitiveStr::Ascii("maniterian"), - dictgen::InsensitiveStr::Ascii("manitis"), - dictgen::InsensitiveStr::Ascii("manitites"), - dictgen::InsensitiveStr::Ascii("manoind"), - dictgen::InsensitiveStr::Ascii("mantiarian"), - dictgen::InsensitiveStr::Ascii("mantiy"), - dictgen::InsensitiveStr::Ascii("mants"), - dictgen::InsensitiveStr::Ascii("merous"), - dictgen::InsensitiveStr::Ascii("miditiy"), - dictgen::InsensitiveStr::Ascii("midiy"), - dictgen::InsensitiveStr::Ascii("miliatin"), - dictgen::InsensitiveStr::Ascii("miliaton"), - dictgen::InsensitiveStr::Ascii("militaing"), - dictgen::InsensitiveStr::Ascii("militaion"), - dictgen::InsensitiveStr::Ascii("militied"), - dictgen::InsensitiveStr::Ascii("millated"), - dictgen::InsensitiveStr::Ascii("millating"), - dictgen::InsensitiveStr::Ascii("millation"), - dictgen::InsensitiveStr::Ascii("minatarian"), - dictgen::InsensitiveStr::Ascii("minoid"), - dictgen::InsensitiveStr::Ascii("mitidy"), - dictgen::InsensitiveStr::Ascii("moros"), - dictgen::InsensitiveStr::Ascii("mouros"), - dictgen::InsensitiveStr::Ascii("murous"), - dictgen::InsensitiveStr::Ascii("nagrian"), - dictgen::InsensitiveStr::Ascii("nagry"), - dictgen::InsensitiveStr::Ascii("nderd"), - dictgen::InsensitiveStr::Ascii("nderds"), - dictgen::InsensitiveStr::Ascii("ndread"), - dictgen::InsensitiveStr::Ascii("ndres"), - dictgen::InsensitiveStr::Ascii("ngarin"), - dictgen::InsensitiveStr::Ascii("ngray"), - dictgen::InsensitiveStr::Ascii("nman"), - dictgen::InsensitiveStr::Ascii("ntmsan"), - dictgen::InsensitiveStr::Ascii("rdels"), - dictgen::InsensitiveStr::Ascii("rldes"), - dictgen::InsensitiveStr::Ascii("rriance"), - dictgen::InsensitiveStr::Ascii("rricaines"), - dictgen::InsensitiveStr::Ascii("rricance"), - dictgen::InsensitiveStr::Ascii("rricances"), - dictgen::InsensitiveStr::Ascii("rricanefps"), - dictgen::InsensitiveStr::Ascii("rricanger"), - dictgen::InsensitiveStr::Ascii("rricans"), - dictgen::InsensitiveStr::Ascii("rriganes"), - dictgen::InsensitiveStr::Ascii("rrikanes"), - dictgen::InsensitiveStr::Ascii("rrycanes"), - dictgen::InsensitiveStr::Ascii("sban"), - dictgen::InsensitiveStr::Ascii("sbandos"), - dictgen::InsensitiveStr::Ascii("sbans"), - dictgen::InsensitiveStr::Ascii("tnsman"), + dictgen::InsensitiveStr::Ascii("ban"), + dictgen::InsensitiveStr::Ascii("bandos"), + dictgen::InsensitiveStr::Ascii("bans"), + dictgen::InsensitiveStr::Ascii("sel"), ], values: &[ - &["haunted"], - &["haunting"], - &["hallucination"], - &["hallucinations"], - &["humanities"], - &["humanoid"], - &["humanist"], - &["humanitarian"], - &["humanitarian"], - &["humanitarian"], - &["humanity"], - &["humanitarian"], - &["humanities"], - &["humanitarian"], - &["humanities"], - &["humanities"], - &["humanoid"], - &["humanitarian"], - &["humanity"], - &["humanist"], - &["humorous"], - &["humidity"], - &["humidity"], - &["humiliation"], - &["humiliation"], - &["humiliating"], - &["humiliation"], - &["humiliated"], - &["humiliated"], - &["humiliating"], - &["humiliation"], - &["humanitarian"], - &["humanoid"], - &["humidity"], - &["humorous"], - &["humorous"], - &["humorous"], - &["hungarian"], - &["hungary"], - &["hundred"], - &["hundreds"], - &["hundred"], - &["hundreds"], - &["hungarian"], - &["hungary"], - &["human"], - &["huntsman"], - &["hurdles"], - &["hurdles"], - &["hurricane"], - &["hurricanes"], - &["hurricane"], - &["hurricanes"], - &["hurricanes"], - &["hurricane"], - &["hurricanes"], - &["hurricanes"], - &["hurricanes"], - &["hurricanes"], &["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: 4..=12, + 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", "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("lucination"), + dictgen::InsensitiveStr::Ascii("lucinations"), + ], + values: &[&["hallucination"], &["hallucinations"]], + range: 10..=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 { @@ -51376,7 +95674,9 @@ static WORD_HT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -51385,19 +95685,25 @@ pub static WORD_HT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ing"), dictgen::InsensitiveStr::Ascii("ink"), dictgen::InsensitiveStr::Ascii("is"), + dictgen::InsensitiveStr::Ascii("mp"), + dictgen::InsensitiveStr::Ascii("ting"), ], values: &[ + &["htaccess"], &["hatching"], - &["then"], - &["there"], + &["the"], + &["then", "hen", "the"], + &["there", "here"], &["they"], &["hitboxes"], &["think"], &["thing"], &["think"], &["this"], + &["html"], + &["hitting"], ], - range: 2..=6, + range: 1..=7, }; static WORD_HS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -51407,13 +95713,59 @@ static WORD_HS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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: &[&["sheldon"], &["historians"], &["history"], &["hysteria"]], - range: 4..=8, + 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 { @@ -51436,14 +95788,14 @@ static WORD_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_HOL_NODE), Some(&WORD_HOM_NODE), Some(&WORD_HON_NODE), - None, + 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), - None, + Some(&WORD_HOV_NODE), Some(&WORD_HOW_NODE), None, None, @@ -51456,9 +95808,27 @@ static WORD_HOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ver")], - values: &[&["however"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("erver"), + dictgen::InsensitiveStr::Ascii("everm"), + dictgen::InsensitiveStr::Ascii("ver"), + ], + values: &[&["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 { @@ -51468,20 +95838,28 @@ static WORD_HOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], - &["hourglass"], - &["hourglass"], - &["households"], - &["households"], &["hours"], + &["hourglass"], + &["hourglass"], + &["thousand"], + &["households"], + &["households"], + &["housekeeping"], + &["hours", "house"], ], range: 2..=8, }; @@ -51494,6 +95872,8 @@ static WORD_HOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -51501,12 +95881,14 @@ pub static WORD_HOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["hotshot"], + &["horizontal"], + &["hostname"], &["hotspot"], &["hotshot"], &["hotspot"], &["hotspot"], ], - range: 4..=5, + range: 4..=7, }; static WORD_HOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -51530,11 +95912,17 @@ pub static WORD_HOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -51551,11 +95939,17 @@ pub static WORD_HOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hospital"], &["hospitalized"], &["hospitals"], + &["hostname"], &["hostels"], &["hotshot"], &["hostility"], &["hostels"], + &["historical"], + &["histories"], + &["history"], &["hotspot"], + &["hotspot"], + &["hotspots"], ], range: 4..=9, }; @@ -51569,14 +95963,20 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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"), @@ -51584,6 +95984,8 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -51593,19 +95995,30 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["horizontal"], &["horizons"], &["horizontal"], + &["horizontal"], &["horizontally"], &["horizontally"], &["horizons"], @@ -51613,6 +96026,8 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["horizontal"], &["horizontally"], &["horizontally"], + &["orphan"], + &["horrible"], &["horrendous"], &["horrendous"], &["horrendous"], @@ -51622,7 +96037,12 @@ pub static WORD_HOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["horribly"], &["horribly"], &["horrifying"], + &["horizontally"], &["horizons"], + &["horizontal"], + &["horizontally"], + &["horizontal"], + &["horizontally"], ], range: 4..=10, }; @@ -51634,32 +96054,71 @@ static WORD_HOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 5..=9, + 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 { @@ -51692,9 +96151,11 @@ static WORD_HOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -51725,6 +96186,13 @@ pub static WORD_HOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -51748,9 +96216,11 @@ pub static WORD_HOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("osexulaity"), ], values: &[ + &["homepage"], &["homecoming"], &["homecoming"], &["homecoming"], + &["homogeneous"], &["homelessness"], &["homelessness"], &["homeopathy"], @@ -51781,6 +96251,13 @@ pub static WORD_HOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["homogeneous"], &["homogeneous"], &["homogeneous"], + &["homogeneously"], + &["homogeneity"], + &["homogeneous"], + &["homogeneously"], + &["homogeneous"], + &["homogeneous"], + &["homogeneously"], &["homogeneous"], &["homophobia"], &["homophobic"], @@ -51817,6 +96294,8 @@ pub static WORD_HOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -51827,6 +96306,8 @@ pub static WORD_HOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["holidays"], &["holdings"], &["hold"], + &["holiday"], + &["holocaust"], &["hollywood"], &["hollywood"], &["holocaust"], @@ -51841,9 +96322,12 @@ static WORD_HOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("pins")], - values: &[&["hopkins"]], - range: 4..=4, + 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 { @@ -51867,12 +96351,20 @@ static WORD_HOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["homeopathy"], &["honestly"], &["hopefully"]], - range: 5..=7, + values: &[ + &["hoax"], + &["homeopathy"], + &["honestly"], + &["hopefully"], + &["however"], + ], + range: 2..=7, }; static WORD_HOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -51886,16 +96378,27 @@ pub static WORD_HOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=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_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, - None, - None, + Some(&WORD_HID_NODE), Some(&WORD_HIE_NODE), None, Some(&WORD_HIG_NODE), @@ -51916,10 +96419,21 @@ static WORD_HI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> 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, @@ -51929,8 +96443,9 @@ pub static WORD_HIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("boxers"), dictgen::InsensitiveStr::Ascii("boxs"), + dictgen::InsensitiveStr::Ascii("ogram"), ], - values: &[&["hitboxes"], &["hitboxes"]], + values: &[&["hitboxes"], &["hitboxes"], &["histogram"]], range: 4..=6, }; @@ -51942,6 +96457,7 @@ static WORD_HIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -51952,7 +96468,9 @@ pub static WORD_HIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tarically"), dictgen::InsensitiveStr::Ascii("terical"), dictgen::InsensitiveStr::Ascii("terically"), + dictgen::InsensitiveStr::Ascii("tgram"), dictgen::InsensitiveStr::Ascii("tocompatability"), + dictgen::InsensitiveStr::Ascii("tori"), dictgen::InsensitiveStr::Ascii("toriaan"), dictgen::InsensitiveStr::Ascii("toricaly"), dictgen::InsensitiveStr::Ascii("toricans"), @@ -51963,10 +96481,24 @@ pub static WORD_HIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -51977,7 +96509,9 @@ pub static WORD_HIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["historically"], &["historical"], &["historically"], + &["histogram"], &["histocompatibility"], + &["history", "historic"], &["historians"], &["historically"], &["historians"], @@ -51988,9 +96522,22 @@ pub static WORD_HIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["histories"], &["historians"], &["historic"], + &["historian"], + &["historians"], + &["historical"], + &["historically"], + &["historically"], + &["historian"], + &["historians"], &["historic"], + &["historical"], + &["historically"], + &["historically"], + &["histories"], + &["history"], + &["history"], ], - range: 4..=15, + range: 3..=15, }; static WORD_HIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52000,11 +96547,24 @@ static WORD_HIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["hiroshima"]], - range: 6..=6, + values: &[ + &["hierarchy"], + &["hierarchies"], + &["hierarchy"], + &["hierarchies"], + &["hierarchy"], + &["hierarchy"], + &["hiroshima"], + ], + range: 4..=7, }; static WORD_HIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52016,6 +96576,7 @@ pub static WORD_HIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -52027,6 +96588,7 @@ pub static WORD_HIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hypocritical"], &["hippopotamus"], &["hypothetical"], + &["hypothetical"], &["hypothetically"], &["hispanics"], &["hipsters"], @@ -52084,9 +96646,21 @@ static WORD_HIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("larious")], - values: &[&["hilarious"]], - range: 7..=7, + 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_HIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52096,39 +96670,89 @@ static WORD_HIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("hlane"), dictgen::InsensitiveStr::Ascii("hlighed"), dictgen::InsensitiveStr::Ascii("hlighing"), 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("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"], &["highlander"], &["highlighted"], &["highlighting"], &["highlighting"], + &["highlight"], + &["highlighted"], + &["highlights"], + &["highlighting"], + &["highlights"], + &["highlight"], &["highlighted"], &["highlighting"], + &["highlighting"], + &["highlights"], &["highlander"], &["highlander"], &["highschool"], &["highschool"], &["highschool"], &["highschool"], + &["height", "high"], + &["higher"], + &["highest"], + &["highlight"], + &["highlighted"], + &["highlighting"], + &["highlights"], + &["height"], + &["highlight"], + &["highlighted"], + &["highlighting"], + &["highlights"], + &["highly"], + &["height"], &["highway"], ], range: 2..=10, @@ -52141,34 +96765,106 @@ static WORD_HIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("rachy"), + dictgen::InsensitiveStr::Ascii("rarachical"), + dictgen::InsensitiveStr::Ascii("rarachy"), + 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"], &["hierarchy"], &["hierarchical"], &["hierarchy"], + &["hierarchy"], + &["hierarchical"], + &["hierarchy"], + &["hierarchical"], + &["hierarchically"], + &["hierarchies"], + &["hierarchy"], + &["hierarchy"], &["hieroglyph"], &["hieroglyphs"], &["heisman"], + &["hiatus"], ], - range: 3..=8, + range: 2..=11, +}; + +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("en"), + ], + values: &[ + &["hidden"], + &["hidden"], + &["hidden", "hiding"], + &["hiding", "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("rchy"), + ], + values: &[&["hierarchical"], &["hierarchy"]], + range: 4..=7, +}; + +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 { @@ -52182,7 +96878,7 @@ static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_HED_NODE), None, - None, + Some(&WORD_HEF_NODE), Some(&WORD_HEG_NODE), None, Some(&WORD_HEI_NODE), @@ -52192,12 +96888,12 @@ static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_HEM_NODE), Some(&WORD_HEN_NODE), Some(&WORD_HEO_NODE), - None, + Some(&WORD_HEP_NODE), None, Some(&WORD_HER_NODE), Some(&WORD_HES_NODE), Some(&WORD_HET_NODE), - None, + Some(&WORD_HEU_NODE), Some(&WORD_HEV_NODE), None, Some(&WORD_HEX_NODE), @@ -52211,9 +96907,13 @@ static WORD_HEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("idecimal")], - values: &[&["hexadecimal"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("ademical"), + dictgen::InsensitiveStr::Ascii("decimal"), + dictgen::InsensitiveStr::Ascii("idecimal"), + ], + values: &[&["hexadecimal"], &["hexadecimal"], &["hexadecimal"]], + range: 7..=8, }; static WORD_HEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52222,9 +96922,27 @@ static WORD_HEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("eanly")], - values: &[&["heavenly"]], - range: 5..=5, + 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"), + ], + values: &[&["heuristic"], &["heuristics"], &["heuristics"]], + range: 5..=7, }; static WORD_HET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52238,12 +96956,16 @@ pub static WORD_HET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, }; @@ -52255,6 +96977,7 @@ static WORD_HES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_HES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("iate"), dictgen::InsensitiveStr::Ascii("iman"), dictgen::InsensitiveStr::Ascii("istant"), dictgen::InsensitiveStr::Ascii("istate"), @@ -52265,6 +96988,7 @@ pub static WORD_HES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tiation"), ], values: &[ + &["hesitate"], &["heisman"], &["hesitant"], &["hesitate"], @@ -52285,6 +97009,7 @@ static WORD_HER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_HER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ad"), + dictgen::InsensitiveStr::Ascii("at"), dictgen::InsensitiveStr::Ascii("athstone"), dictgen::InsensitiveStr::Ascii("atige"), dictgen::InsensitiveStr::Ascii("clues"), @@ -52295,6 +97020,7 @@ pub static WORD_HER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -52308,12 +97034,16 @@ pub static WORD_HER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["heard", "hera"], + &["heart"], &["hearthstone"], &["heritage"], &["hercules"], @@ -52324,6 +97054,7 @@ pub static WORD_HER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hercules"], &["hercules"], &["hercules"], + &["here"], &["heterosexual"], &["heterosexual"], &["hierarchy"], @@ -52337,13 +97068,27 @@ pub static WORD_HER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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, @@ -52364,9 +97109,14 @@ static WORD_HEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ious")], - values: &[&["heinous"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("c"), + dictgen::InsensitiveStr::Ascii("derence"), + dictgen::InsensitiveStr::Ascii("dler"), + dictgen::InsensitiveStr::Ascii("ious"), + ], + values: &[&["hence"], &["hindrance"], &["handler"], &["heinous"]], + range: 1..=7, }; static WORD_HEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52384,6 +97134,7 @@ pub static WORD_HEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ishperes"), dictgen::InsensitiveStr::Ascii("lets"), dictgen::InsensitiveStr::Ascii("morhage"), + dictgen::InsensitiveStr::Ascii("orage"), dictgen::InsensitiveStr::Ascii("pishere"), ], values: &[ @@ -52392,9 +97143,10 @@ pub static WORD_HEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hemisphere"], &["hemisphere"], &["hemisphere"], - &["hemisphere"], + &["hemisphere", "hemispheres"], &["helmets"], &["hemorrhage"], + &["hemorrhage"], &["hemisphere"], ], range: 4..=8, @@ -52402,13 +97154,14 @@ pub static WORD_HEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict static WORD_HEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_HEL_CHILDREN), - value: None, + 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"), @@ -52423,17 +97176,23 @@ pub static WORD_HEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("oer"), + dictgen::InsensitiveStr::Ascii("oers"), + dictgen::InsensitiveStr::Ascii("pe"), dictgen::InsensitiveStr::Ascii("pfull"), + dictgen::InsensitiveStr::Ascii("pfuly"), dictgen::InsensitiveStr::Ascii("pped"), ], values: &[ &["healthcare"], &["helmets"], + &["helpers"], &["helicopters"], &["helicopters"], &["helicopter"], @@ -52448,15 +97207,20 @@ pub static WORD_HEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["helicopters"], &["hellfire"], &["hellfire"], + &["hello"], &["hallucination"], &["hallucinations"], &["helluva"], &["helluva"], &["helmet"], + &["helper"], + &["helpers"], + &["helper"], &["helpful"], + &["helpfully"], &["helped"], ], - range: 4..=11, + range: 2..=11, }; static WORD_HEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52467,13 +97231,24 @@ static WORD_HEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -52482,20 +97257,31 @@ pub static WORD_HEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["heidelberg"], + &["highest"], + &["height", "high"], &["higher"], - &["heights"], + &["heights", "highest"], + &["height"], &["heightened"], + &["eighteen"], &["heightened"], + &["height"], + &["height"], &["heightened"], &["heights"], + &["hierarchies"], &["hierarchy"], + &["hierarchic"], + &["hierarchical"], + &["hierarchically"], + &["hierarchies"], &["hierarchy"], &["hieroglyphics"], &["hesitant"], &["hesitate"], &["hesitation"], ], - range: 4..=10, + range: 2..=11, }; static WORD_HEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52509,6 +97295,17 @@ pub static WORD_HEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -52539,6 +97336,8 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dhpone"), dictgen::InsensitiveStr::Ascii("dhpones"), dictgen::InsensitiveStr::Ascii("dhsot"), + dictgen::InsensitiveStr::Ascii("dle"), + dictgen::InsensitiveStr::Ascii("dong"), dictgen::InsensitiveStr::Ascii("dphoens"), dictgen::InsensitiveStr::Ascii("dqaurters"), dictgen::InsensitiveStr::Ascii("dquarer"), @@ -52546,10 +97345,12 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dquater"), dictgen::InsensitiveStr::Ascii("dquatered"), dictgen::InsensitiveStr::Ascii("dquaters"), + dictgen::InsensitiveStr::Ascii("drom"), dictgen::InsensitiveStr::Ascii("dseat"), dictgen::InsensitiveStr::Ascii("dses"), dictgen::InsensitiveStr::Ascii("dshoot"), dictgen::InsensitiveStr::Ascii("dshoots"), + dictgen::InsensitiveStr::Ascii("er"), dictgen::InsensitiveStr::Ascii("lither"), dictgen::InsensitiveStr::Ascii("ltchare"), dictgen::InsensitiveStr::Ascii("ltheast"), @@ -52574,6 +97375,7 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rtsthone"), dictgen::InsensitiveStr::Ascii("stink"), dictgen::InsensitiveStr::Ascii("thern"), + dictgen::InsensitiveStr::Ascii("thy"), dictgen::InsensitiveStr::Ascii("tlhcare"), dictgen::InsensitiveStr::Ascii("tskin"), dictgen::InsensitiveStr::Ascii("veny"), @@ -52595,6 +97397,8 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["headphone"], &["headphones"], &["headshot"], + &["handle"], + &["heading"], &["headphones"], &["headquarters"], &["headquarter"], @@ -52602,10 +97406,12 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["headquarter"], &["headquartered"], &["headquarters"], + &["headroom", "bedroom"], &["headset"], &["headsets"], &["headshot"], &["headshot"], + &["header"], &["healthier"], &["healthcare"], &["healthiest"], @@ -52617,7 +97423,7 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["healthiest"], &["headphone"], &["headphones"], - &["heard"], + &["heard", "header"], &["hearthstone"], &["heartbeat"], &["heartbeat"], @@ -52630,6 +97436,7 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hearthstone"], &["heatsink"], &["heathen"], + &["healthy"], &["healthcare"], &["heatsink"], &["heavenly"], @@ -52643,7 +97450,7 @@ pub static WORD_HEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["heavyweight"], &["heavyweight"], ], - range: 3..=9, + range: 2..=9, }; static WORD_HD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52652,9 +97459,12 @@ static WORD_HD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_HD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("insight")], - values: &[&["hindsight"]], - range: 7..=7, + 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 { @@ -52663,14 +97473,14 @@ static WORD_HA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_HAA_NODE), Some(&WORD_HAB_NODE), Some(&WORD_HAC_NODE), - None, + Some(&WORD_HAD_NODE), Some(&WORD_HAE_NODE), Some(&WORD_HAF_NODE), None, - None, + Some(&WORD_HAH_NODE), Some(&WORD_HAI_NODE), None, None, @@ -52681,28 +97491,63 @@ static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_HAP_NODE), None, Some(&WORD_HAR_NODE), - None, + Some(&WORD_HAS_NODE), Some(&WORD_HAT_NODE), Some(&WORD_HAU_NODE), Some(&WORD_HAV_NODE), None, None, - None, - None, + 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_HAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_HAV_CHILDREN), - value: None, + 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"), ], - values: &[&["harvesting"], &["heaviest"]], - range: 4..=7, + values: &[ + &["have"], + &["have"], + &["have"], + &["having"], + &["harvesting"], + &["have"], + &["heaviest"], + ], + range: 1..=7, }; static WORD_HAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52711,9 +97556,12 @@ static WORD_HAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_HAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ntig")], - values: &[&["haunting"]], - range: 4..=4, + 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 { @@ -52739,6 +97587,31 @@ pub static WORD_HAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("k"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[ + &["hashes"], + &["hash"], + &["hashes"], + &["hashes"], + &["hash"], + &["hash"], + ], + range: 1..=4, +}; + static WORD_HAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_HAR_CHILDREN), value: None, @@ -52751,10 +97624,20 @@ pub static WORD_HAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -52766,13 +97649,17 @@ pub static WORD_HAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -52780,10 +97667,20 @@ pub static WORD_HAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["harassment"], &["harassments"], &["harassment"], + &["hardcode", "charcode"], + &["hardcoded"], + &["hardcodes", "charcodes"], + &["hardcoding"], + &["hardware"], &["hardened"], &["hardened"], + &["hardcode"], + &["hardware"], + &["hardware"], + &["hardwired"], &["hardwood"], &["hardwood"], + &["charge"], &["haircut"], &["hairstyle"], &["hardline"], @@ -52795,15 +97692,19 @@ pub static WORD_HAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["harassing"], &["harassment"], &["harassments"], + &["harass"], &["harassed"], &["harassed"], &["harassing"], &["harassment"], &["harassments"], + &["hearth"], &["harvesting"], &["harvesting"], + &["hardware"], + &["hardware"], ], - range: 3..=9, + range: 2..=9, }; static WORD_HAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52814,33 +97715,71 @@ static WORD_HAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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..=6, + range: 2..=8, }; static WORD_HAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52858,66 +97797,280 @@ pub static WORD_HAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_HAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_HAN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_HAN_CHILDREN), value: None, }; -pub static WORD_HAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("dbok"), - dictgen::InsensitiveStr::Ascii("dboook"), - dictgen::InsensitiveStr::Ascii("dcuffes"), - dictgen::InsensitiveStr::Ascii("dcufs"), - dictgen::InsensitiveStr::Ascii("dedley"), - dictgen::InsensitiveStr::Ascii("dedlly"), - dictgen::InsensitiveStr::Ascii("dedy"), - dictgen::InsensitiveStr::Ascii("delbars"), - dictgen::InsensitiveStr::Ascii("deld"), - dictgen::InsensitiveStr::Ascii("deldy"), - dictgen::InsensitiveStr::Ascii("dicape"), - dictgen::InsensitiveStr::Ascii("dicaped"), - dictgen::InsensitiveStr::Ascii("dlade"), - dictgen::InsensitiveStr::Ascii("dlare"), - dictgen::InsensitiveStr::Ascii("dlebards"), - dictgen::InsensitiveStr::Ascii("dledy"), - dictgen::InsensitiveStr::Ascii("drwiting"), - dictgen::InsensitiveStr::Ascii("dwritng"), - dictgen::InsensitiveStr::Ascii("dwritting"), - dictgen::InsensitiveStr::Ascii("dycapped"), - dictgen::InsensitiveStr::Ascii("idcapped"), - dictgen::InsensitiveStr::Ascii("lder"), - dictgen::InsensitiveStr::Ascii("nbial"), - dictgen::InsensitiveStr::Ascii("nibl"), - dictgen::InsensitiveStr::Ascii("uted"), + 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("ibl"), + ], + values: &[&["hannibal"], &["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_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::Flat(&WORD_HAND_CHILDREN), + value: None, +}; + +pub static WORD_HAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("bok"), + dictgen::InsensitiveStr::Ascii("boook"), + dictgen::InsensitiveStr::Ascii("cuffes"), + dictgen::InsensitiveStr::Ascii("cufs"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("edley"), + dictgen::InsensitiveStr::Ascii("edlly"), + dictgen::InsensitiveStr::Ascii("edy"), + dictgen::InsensitiveStr::Ascii("el"), + dictgen::InsensitiveStr::Ascii("elbars"), + dictgen::InsensitiveStr::Ascii("eld"), + dictgen::InsensitiveStr::Ascii("eldy"), + dictgen::InsensitiveStr::Ascii("eled"), + dictgen::InsensitiveStr::Ascii("eler"), + dictgen::InsensitiveStr::Ascii("eles"), + dictgen::InsensitiveStr::Ascii("eling"), + dictgen::InsensitiveStr::Ascii("els"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("full"), + dictgen::InsensitiveStr::Ascii("hake"), + dictgen::InsensitiveStr::Ascii("icape"), + dictgen::InsensitiveStr::Ascii("icaped"), + dictgen::InsensitiveStr::Ascii("lade"), + dictgen::InsensitiveStr::Ascii("lare"), + dictgen::InsensitiveStr::Ascii("lebards"), + dictgen::InsensitiveStr::Ascii("ledy"), + dictgen::InsensitiveStr::Ascii("leer"), + dictgen::InsensitiveStr::Ascii("leing"), + dictgen::InsensitiveStr::Ascii("lig"), + dictgen::InsensitiveStr::Ascii("lling"), + dictgen::InsensitiveStr::Ascii("rwiting"), + dictgen::InsensitiveStr::Ascii("sake"), + dictgen::InsensitiveStr::Ascii("shacke"), + dictgen::InsensitiveStr::Ascii("shackes"), + dictgen::InsensitiveStr::Ascii("shacking"), + dictgen::InsensitiveStr::Ascii("shage"), + dictgen::InsensitiveStr::Ascii("shages"), + dictgen::InsensitiveStr::Ascii("shaging"), + dictgen::InsensitiveStr::Ascii("shak"), + dictgen::InsensitiveStr::Ascii("shakng"), + dictgen::InsensitiveStr::Ascii("shakre"), + dictgen::InsensitiveStr::Ascii("shakres"), + dictgen::InsensitiveStr::Ascii("shakring"), + dictgen::InsensitiveStr::Ascii("shaks"), + dictgen::InsensitiveStr::Ascii("shale"), + dictgen::InsensitiveStr::Ascii("shales"), + dictgen::InsensitiveStr::Ascii("shaling"), + dictgen::InsensitiveStr::Ascii("share"), + dictgen::InsensitiveStr::Ascii("shares"), + dictgen::InsensitiveStr::Ascii("sharing"), + dictgen::InsensitiveStr::Ascii("shk"), + dictgen::InsensitiveStr::Ascii("shke"), + dictgen::InsensitiveStr::Ascii("shkes"), + dictgen::InsensitiveStr::Ascii("shking"), + dictgen::InsensitiveStr::Ascii("shkng"), + dictgen::InsensitiveStr::Ascii("shks"), + dictgen::InsensitiveStr::Ascii("skake"), + dictgen::InsensitiveStr::Ascii("wirting"), + dictgen::InsensitiveStr::Ascii("writng"), + dictgen::InsensitiveStr::Ascii("writting"), + dictgen::InsensitiveStr::Ascii("ycapped"), ], values: &[ &["handbook"], &["handbook"], &["handcuffs"], &["handcuffs"], + &["handle", "hand"], &["handedly"], &["handedly"], &["handedly"], + &["handle"], &["handlebars"], - &["handled"], + &["handled", "handheld"], &["handedly"], + &["handled", "handheld"], + &["handler"], + &["handles"], + &["handling"], + &["handles"], + &["handler"], + &["handful"], + &["handshake"], &["handicapped"], &["handicapped"], &["handled"], &["handler"], &["handlebars"], &["handedly"], - &["handwriting"], - &["handwriting"], - &["handwriting"], - &["handicapped"], - &["handicapped"], &["handler"], - &["hannibal"], - &["hannibal"], - &["haunted"], + &["handling"], + &["handling"], + &["handling"], + &["handwriting"], + &["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"], + &["handwriting"], + &["handwriting"], + &["handwriting"], + &["handicapped"], ], - range: 4..=9, + range: 1..=8, }; static WORD_HAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52941,7 +98094,9 @@ pub static WORD_HAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: &[ @@ -52959,10 +98114,12 @@ pub static WORD_HAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hamburgers"], &["hamilton"], &["hamilton"], + &["hammer"], &["hampshire"], + &["hamster"], &["hampshire"], ], - range: 5..=8, + range: 4..=8, }; static WORD_HAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -52973,12 +98130,15 @@ static WORD_HAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -52996,17 +98156,21 @@ pub static WORD_HAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("luzination"), dictgen::InsensitiveStr::Ascii("luzinations"), dictgen::InsensitiveStr::Ascii("p"), + dictgen::InsensitiveStr::Ascii("points"), ], values: &[ &["hilarious"], + &["held"], &["halifax"], &["halftime"], + &["halves"], &["hallucination"], &["hallucination"], &["hallucination"], &["hallucinations"], &["halloween"], &["halloween"], + &["halloween"], &["hallucination"], &["hallucinations"], &["hallucinations"], @@ -53022,6 +98186,7 @@ pub static WORD_HAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["hallucination"], &["hallucinations"], &["help"], + &["halfpoints"], ], range: 1..=11, }; @@ -53042,6 +98207,17 @@ pub static WORD_HAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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_HAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_HAF_CHILDREN), value: None, @@ -53060,23 +98236,58 @@ static WORD_HAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["haemorrhage"], &["heathen"], &["have"]], + 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("ling"), + dictgen::InsensitiveStr::Ascii("nler"), + ], + values: &[ + &["headers", "shaders", "haters"], + &["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("thing")], - values: &[&["hatching"]], - range: 5..=5, + 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 { @@ -53087,13 +98298,32 @@ static WORD_HAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["habeas"], &["habsburg"]], + 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: &[], + values: &[], + range: 0..=0, +}; + static WORD_G_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_G_CHILDREN), value: None, @@ -53106,7 +98336,7 @@ static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_GE_NODE), None, - None, + Some(&WORD_GG_NODE), Some(&WORD_GH_NODE), Some(&WORD_GI_NODE), None, @@ -53125,9 +98355,23 @@ static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, None, Some(&WORD_GY_NODE), - None, + 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, @@ -53135,6 +98379,7 @@ static WORD_GY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("nmastics"), @@ -53142,13 +98387,14 @@ pub static WORD_GY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("spies"), ], values: &[ + &["glyph"], &["gymnastics"], &["gymnastics"], &["gymnastics"], &["gypsies"], &["gypsies"], ], - range: 5..=8, + range: 3..=8, }; static WORD_GU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53160,7 +98406,7 @@ static WORD_GU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_GUA_NODE), None, None, - None, + Some(&WORD_GUD_NODE), Some(&WORD_GUE_NODE), None, None, @@ -53213,8 +98459,10 @@ pub static WORD_GUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -53222,10 +98470,12 @@ pub static WORD_GUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["guarding"], &["guarantee"], &["guaranteed"], + &["guaranteeing"], &["guarantees"], &["gruesome"], + &["guarantee"], ], - range: 5..=6, + range: 5..=8, }; static WORD_GUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53285,6 +98535,8 @@ static WORD_GUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_GUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("dence"), + dictgen::InsensitiveStr::Ascii("dline"), + dictgen::InsensitiveStr::Ascii("dlines"), dictgen::InsensitiveStr::Ascii("lia"), dictgen::InsensitiveStr::Ascii("lio"), dictgen::InsensitiveStr::Ascii("ness"), @@ -53295,6 +98547,8 @@ pub static WORD_GUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["guidance"], + &["guideline"], + &["guidelines"], &["giulia"], &["giulio"], &["guinness"], @@ -53303,7 +98557,7 @@ pub static WORD_GUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["guitars"], &["guitarist"], ], - range: 3..=5, + range: 3..=6, }; static WORD_GUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53316,94 +98570,564 @@ pub static WORD_GUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rrila"), dictgen::InsensitiveStr::Ascii("rrilas"), dictgen::InsensitiveStr::Ascii("rrillera"), + dictgen::InsensitiveStr::Ascii("swork"), + ], + values: &[ + &["guerrilla"], + &["guerrillas"], + &["guerrilla"], + &["guesswork"], ], - values: &[&["guerrilla"], &["guerrillas"], &["guerrilla"]], range: 5..=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_GUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_GUA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_GUA_CHILDREN), value: None, }; -pub static WORD_GUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("duloupe"), - dictgen::InsensitiveStr::Ascii("dulupe"), - dictgen::InsensitiveStr::Ascii("ge"), - dictgen::InsensitiveStr::Ascii("natanmo"), - dictgen::InsensitiveStr::Ascii("ntamamo"), - dictgen::InsensitiveStr::Ascii("ntamano"), - dictgen::InsensitiveStr::Ascii("ntanameow"), - dictgen::InsensitiveStr::Ascii("ntanamero"), - dictgen::InsensitiveStr::Ascii("ntanano"), - dictgen::InsensitiveStr::Ascii("ntanemo"), - dictgen::InsensitiveStr::Ascii("ntano"), - dictgen::InsensitiveStr::Ascii("ntanoma"), - dictgen::InsensitiveStr::Ascii("ntanomo"), - dictgen::InsensitiveStr::Ascii("ntonamo"), - dictgen::InsensitiveStr::Ascii("ranted"), - dictgen::InsensitiveStr::Ascii("ranteeds"), - dictgen::InsensitiveStr::Ascii("rantes"), - dictgen::InsensitiveStr::Ascii("rantess"), - dictgen::InsensitiveStr::Ascii("rdain"), - dictgen::InsensitiveStr::Ascii("rdains"), - dictgen::InsensitiveStr::Ascii("rdiands"), - dictgen::InsensitiveStr::Ascii("rdianes"), - dictgen::InsensitiveStr::Ascii("rdianis"), - dictgen::InsensitiveStr::Ascii("rdias"), - dictgen::InsensitiveStr::Ascii("rdin"), - dictgen::InsensitiveStr::Ascii("rentee"), - dictgen::InsensitiveStr::Ascii("renteed"), - dictgen::InsensitiveStr::Ascii("rentees"), - dictgen::InsensitiveStr::Ascii("ridan"), - dictgen::InsensitiveStr::Ascii("ridans"), - dictgen::InsensitiveStr::Ascii("rnateed"), - dictgen::InsensitiveStr::Ascii("rnatees"), - dictgen::InsensitiveStr::Ascii("runteed"), - dictgen::InsensitiveStr::Ascii("runtees"), - dictgen::InsensitiveStr::Ascii("tamala"), - dictgen::InsensitiveStr::Ascii("tamalan"), + 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: &[ - &["guadalupe"], - &["guadalupe"], - &["gage"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guantanamo"], - &["guaranteed"], - &["guarantees"], - &["guarantees"], - &["guarantees"], - &["guardian"], - &["guardians"], - &["guardians"], - &["guardians"], - &["guardians"], - &["guardians"], - &["guardian"], &["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"], - &["guaranteed"], - &["guarantees"], - &["guaranteed"], - &["guarantees"], - &["guatemala"], - &["guatemalan"], + &["guardians"], + &["guardians"], + &["guardians"], + &["guardians"], + &["guardian"], ], - range: 2..=9, + 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("nted"), + dictgen::InsensitiveStr::Ascii("nteeds"), + dictgen::InsensitiveStr::Ascii("nteey"), + dictgen::InsensitiveStr::Ascii("ntes"), + dictgen::InsensitiveStr::Ascii("ntess"), + dictgen::InsensitiveStr::Ascii("ntie"), + ], + values: &[ + &["guaranteed"], + &["guarantees"], + &["guaranty"], + &["guarantees"], + &["guarantees"], + &["guarantee"], + ], + range: 4..=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", "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 { @@ -53413,7 +99137,7 @@ static WORD_GR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_GRA_NODE), - None, + Some(&WORD_GRB_NODE), None, None, Some(&WORD_GRE_NODE), @@ -53429,7 +99153,7 @@ static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_GRO_NODE), Some(&WORD_GRP_NODE), None, - None, + Some(&WORD_GRR_NODE), None, None, Some(&WORD_GRU_NODE), @@ -53457,8 +99181,24 @@ static WORD_GRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_GRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("seome")], - values: &[&["gruesome"]], + keys: &[ + dictgen::InsensitiveStr::Ascii("op"), + dictgen::InsensitiveStr::Ascii("opd"), + dictgen::InsensitiveStr::Ascii("ops"), + dictgen::InsensitiveStr::Ascii("seome"), + ], + values: &[&["group"], &["grouped"], &["groups"], &["gruesome"]], + range: 2..=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, }; @@ -53492,12 +99232,42 @@ static WORD_GRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("oup"), + dictgen::InsensitiveStr::Ascii("ouped"), + dictgen::InsensitiveStr::Ascii("ouping"), + dictgen::InsensitiveStr::Ascii("oups"), + dictgen::InsensitiveStr::Ascii("p"), dictgen::InsensitiveStr::Ascii("pu"), + dictgen::InsensitiveStr::Ascii("pus"), dictgen::InsensitiveStr::Ascii("ubdbreaking"), + dictgen::InsensitiveStr::Ascii("ubpy"), dictgen::InsensitiveStr::Ascii("udnbreaking"), + dictgen::InsensitiveStr::Ascii("upd"), + dictgen::InsensitiveStr::Ascii("upes"), + dictgen::InsensitiveStr::Ascii("upt"), ], - values: &[&["group"], &["groundbreaking"], &["groundbreaking"]], - range: 2..=11, + values: &[ + &["global"], + &["globally"], + &["geometry"], + &["group"], + &["grouped"], + &["grouping"], + &["groups"], + &["group", "drop"], + &["group"], + &["groups", "gropes"], + &["groundbreaking"], + &["groupby"], + &["groundbreaking"], + &["grouped"], + &["groups", "grouped"], + &["grouped"], + ], + range: 1..=11, }; static WORD_GRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53512,6 +99282,7 @@ pub static WORD_GRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -53525,6 +99296,7 @@ pub static WORD_GRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["griefing"], &["grievances"], &["griefing"], + &["gregorian"], &["girlfriend"], &["girlfriends"], &["grilling"], @@ -53544,8 +99316,12 @@ pub static WORD_GRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -53556,14 +99332,21 @@ pub static WORD_GRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -53574,12 +99357,26 @@ pub static WORD_GRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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, @@ -53660,11 +99457,12 @@ pub static WORD_GRAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic static WORD_GRAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_GRAT_CHILDREN), - value: None, + 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"), @@ -53678,6 +99476,7 @@ pub static WORD_GRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("utious"), ], values: &[ + &["grateful"], &["gratification"], &["gratification"], &["gratuitous"], @@ -53716,30 +99515,38 @@ pub static WORD_GRAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: 3..=7, + range: 2..=7, }; static WORD_GRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53749,14 +99556,19 @@ static WORD_GRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("iet"), + dictgen::InsensitiveStr::Ascii("ilarity"), dictgen::InsensitiveStr::Ascii("olla"), dictgen::InsensitiveStr::Ascii("tie"), + dictgen::InsensitiveStr::Ascii("uality"), + dictgen::InsensitiveStr::Ascii("ualtiry"), + dictgen::InsensitiveStr::Ascii("ulatiry"), ], values: &[ &["grandchildren"], @@ -53764,9 +99576,14 @@ pub static WORD_GRAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["grandchildren"], &["grandchildren"], &["grandchildren"], + &["grandchildren"], &["granite"], + &["granularity"], &["granola"], &["granite"], + &["granularity"], + &["granularity"], + &["granularity"], ], range: 3..=10, }; @@ -53778,26 +99595,34 @@ static WORD_GRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: 3..=11, + range: 2..=11, }; static WORD_GRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53821,6 +99646,9 @@ static WORD_GRAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -53828,13 +99656,16 @@ pub static WORD_GRAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("pite"), ], values: &[ + &["graphic"], + &["graphical"], + &["graphics"], &["graphic"], &["graphical"], &["graphically"], &["graphics"], &["graphite"], ], - range: 3..=7, + range: 2..=7, }; static WORD_GRAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53844,11 +99675,12 @@ static WORD_GRAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["garfield"], &["graffiti"]], - range: 4..=4, + values: &[&["graphics"], &["garfield"], &["graffiti"]], + range: 3..=4, }; static WORD_GRAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -53910,9 +99742,13 @@ static WORD_GRAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_GRAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("age")], - values: &[&["garbage"]], - range: 3..=3, + 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 { @@ -53970,6 +99806,7 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -53982,6 +99819,7 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -54006,6 +99844,7 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["government"], &["government"], &["government"], + &["governor"], &["government"], &["governments"], &["governance"], @@ -54019,6 +99858,7 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["governments"], &["government"], &["government"], + &["government"], &["governmental"], &["governments"], &["governed"], @@ -54038,7 +99878,7 @@ pub static WORD_GOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["government"], &["government"], ], - range: 5..=10, + range: 4..=10, }; static WORD_GOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54080,9 +99920,10 @@ pub static WORD_GOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("epls"), dictgen::InsensitiveStr::Ascii("pells"), dictgen::InsensitiveStr::Ascii("ples"), + dictgen::InsensitiveStr::Ascii("t"), ], - values: &[&["gospels"], &["gospels"], &["gospels"]], - range: 4..=5, + values: &[&["gospels"], &["gospels"], &["gospels"], &["ghost"]], + range: 1..=5, }; static WORD_GOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54092,24 +99933,30 @@ static WORD_GOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("vement"), ], values: &[ + &["gourd"], &["gorgeous"], &["foreshadowing"], &["gorgeous"], &["gorilla"], &["gorilla"], &["gourmet"], + &["gory"], + &["gourmet"], &["government"], ], - range: 4..=10, + range: 1..=10, }; static WORD_GOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54121,6 +99968,7 @@ pub static WORD_GOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -54130,13 +99978,14 @@ pub static WORD_GOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["goodluck"], &["goodluck"], + &["ghoul"], &["goosebumps"], &["goosebumps"], &["goosebumps"], &["goosebumps"], &["goosebumps"], ], - range: 4..=8, + range: 1..=8, }; static WORD_GON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54163,6 +100012,9 @@ pub static WORD_GOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -54175,6 +100027,9 @@ pub static WORD_GOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["goliath"], &["goalkeeper"], + &["global"], + &["globally"], + &["globally"], &["goblins"], &["goldman"], &["goldberg"], @@ -54184,7 +100039,7 @@ pub static WORD_GOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["godlike"], &["goliath"], ], - range: 4..=7, + range: 3..=7, }; static WORD_GOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54196,9 +100051,11 @@ pub static WORD_GOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("gn"), dictgen::InsensitiveStr::Ascii("lath"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("nd"), ], - values: &[&["going"], &["goliath"]], - range: 2..=4, + values: &[&["going"], &["goliath"], &["going"], &["going"]], + range: 1..=4, }; static WORD_GOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54207,9 +100064,12 @@ static WORD_GOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_GOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("in")], - values: &[&["going"]], - range: 2..=2, + 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 { @@ -54223,16 +100083,20 @@ pub static WORD_GOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: 4..=11, + range: 2..=11, }; static WORD_GOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54286,9 +100150,12 @@ static WORD_GOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_GOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lings")], - values: &[&["goblins"]], - range: 5..=5, + 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 { @@ -54321,8 +100188,10 @@ pub static WORD_GN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("aking"), dictgen::InsensitiveStr::Ascii("awwed"), + dictgen::InsensitiveStr::Ascii("erate"), + dictgen::InsensitiveStr::Ascii("orung"), ], - values: &[&["ganking"], &["gnawed"]], + values: &[&["ganking"], &["gnawed"], &["generate"], &["ignoring"]], range: 5..=5, }; @@ -54364,19 +100233,33 @@ pub static WORD_GL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("obablly"), dictgen::InsensitiveStr::Ascii("obaly"), + dictgen::InsensitiveStr::Ascii("obbal"), + dictgen::InsensitiveStr::Ascii("obel"), 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"], @@ -54399,21 +100282,35 @@ pub static WORD_GL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["glitched"], &["glitches"], &["glitchy"], + &["globe"], + &["global"], &["global"], &["globally"], &["globally"], + &["globally"], + &["global"], + &["global"], &["goldberg"], &["goldfish"], &["goliath"], &["glorified"], &["glorified"], + &["glorified"], &["glorious"], &["glorious"], + &["glyph"], + &["glyphs"], &["glitched"], &["glitches"], &["glitchy"], + &["glyph"], + &["glyphs"], + &["glyphed"], + &["glyphs"], + &["glyphing"], + &["glycerin"], ], - range: 4..=9, + range: 2..=9, }; static WORD_GI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54429,15 +100326,22 @@ pub static WORD_GI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("rafffe"), dictgen::InsensitiveStr::Ascii("refing"), dictgen::InsensitiveStr::Ascii("rlfirend"), @@ -54451,6 +100355,17 @@ pub static WORD_GI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("vveing"), + dictgen::InsensitiveStr::Ascii("vven"), + dictgen::InsensitiveStr::Ascii("vving"), ], values: &[ &["gigabyte"], @@ -54459,15 +100374,22 @@ pub static WORD_GI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["gigantic"], &["gigabyte"], &["gigabyte"], + &["gigabit"], &["gigantic"], + &["guillotine"], &["glitched"], &["glitches"], &["glitchy"], + &["guilty"], &["gimmicks"], &["gimmicky"], &["gimmicky"], &["gimmicks"], &["gimmicky"], + &["guinea"], + &["gingham"], + &["given"], + &["git"], &["giraffe"], &["griefing"], &["girlfriend"], @@ -54481,8 +100403,19 @@ pub static WORD_GI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["girlfriends"], &["grilling"], &["grizzly"], + &["geyser"], + &["geysers"], + &["guitar"], + &["guitars"], + &["gitattributes"], + &["given", "gave"], + &["giving"], + &["given"], + &["giving"], + &["given"], + &["giving"], ], - range: 5..=9, + range: 1..=10, }; static WORD_GH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54491,9 +100424,28 @@ static WORD_GH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_GH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("andi")], - values: &[&["gandhi"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("andi"), + dictgen::InsensitiveStr::Ascii("ostscritp"), + dictgen::InsensitiveStr::Ascii("raphic"), + ], + values: &[&["gandhi"], &["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 { @@ -54506,7 +100458,7 @@ static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, + Some(&WORD_GEE_NODE), None, None, None, @@ -54520,8 +100472,8 @@ static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_GER_NODE), - None, - None, + Some(&WORD_GES_NODE), + Some(&WORD_GET_NODE), Some(&WORD_GEU_NODE), None, None, @@ -54541,6 +100493,60 @@ pub static WORD_GEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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"], + &["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, @@ -54548,26 +100554,64 @@ static WORD_GER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("eating"), + 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"], + &["generating"], + &["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: 2..=7, + range: 2..=8, }; static WORD_GEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54577,10 +100621,15 @@ static WORD_GEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -54591,18 +100640,38 @@ pub static WORD_GEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("grpahical"), dictgen::InsensitiveStr::Ascii("grpahically"), dictgen::InsensitiveStr::Ascii("grpahy"), + dictgen::InsensitiveStr::Ascii("io"), 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("mtery"), + dictgen::InsensitiveStr::Ascii("mtry"), + dictgen::InsensitiveStr::Ascii("mtrys"), 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"], @@ -54613,14 +100682,29 @@ pub static WORD_GEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["geographical"], &["geographically"], &["geography"], + &["geoip"], &["geometry"], + &["geometry"], + &["geometries"], + &["geometric", "geometry"], + &["geometer"], &["geometers"], &["geometry"], + &["geometries"], &["geometry"], + &["geometry"], + &["geometrically"], + &["geometric"], + &["geometrically"], + &["geometry"], + &["geometry"], + &["geometry"], + &["geometries"], &["geographically"], + &["georeferencing"], &["georgia"], ], - range: 4..=11, + range: 2..=11, }; static WORD_GEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54665,17 +100749,19 @@ static WORD_GENU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: 4..=6, + range: 2..=6, }; static WORD_GENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54686,6 +100772,7 @@ static WORD_GENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -54694,13 +100781,14 @@ pub static WORD_GENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["genitalia"], + &["gentle"], &["gentlemen"], &["genitalia"], &["genitals"], &["gentlemen"], &["gentlemen"], ], - range: 4..=7, + range: 2..=7, }; static WORD_GENR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54709,9 +100797,67 @@ static WORD_GENR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_GENR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ates")], - values: &[&["generates"]], - range: 4..=4, + 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("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"], + &["generics"], + ], + range: 2..=10, }; static WORD_GENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54748,60 +100894,260 @@ pub static WORD_GENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_GENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_GENE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_GENE_CHILDREN), value: None, }; -pub static WORD_GENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ological"), - dictgen::InsensitiveStr::Ascii("ologies"), - dictgen::InsensitiveStr::Ascii("ology"), - dictgen::InsensitiveStr::Ascii("racional"), - dictgen::InsensitiveStr::Ascii("ralbs"), - dictgen::InsensitiveStr::Ascii("ralice"), - dictgen::InsensitiveStr::Ascii("ralife"), - dictgen::InsensitiveStr::Ascii("ralis"), - dictgen::InsensitiveStr::Ascii("ralizacion"), - dictgen::InsensitiveStr::Ascii("ralizaing"), - dictgen::InsensitiveStr::Ascii("ralizare"), - dictgen::InsensitiveStr::Ascii("ralizate"), - dictgen::InsensitiveStr::Ascii("ralizating"), - dictgen::InsensitiveStr::Ascii("ralizaton"), - dictgen::InsensitiveStr::Ascii("ralizng"), - dictgen::InsensitiveStr::Ascii("ralnie"), - dictgen::InsensitiveStr::Ascii("raly"), - dictgen::InsensitiveStr::Ascii("ras"), - dictgen::InsensitiveStr::Ascii("rase"), - dictgen::InsensitiveStr::Ascii("raste"), - dictgen::InsensitiveStr::Ascii("raters"), - dictgen::InsensitiveStr::Ascii("ratie"), - dictgen::InsensitiveStr::Ascii("raties"), - dictgen::InsensitiveStr::Ascii("ratin"), - dictgen::InsensitiveStr::Ascii("rationals"), - dictgen::InsensitiveStr::Ascii("rationens"), - dictgen::InsensitiveStr::Ascii("rationers"), - dictgen::InsensitiveStr::Ascii("rationnal"), - dictgen::InsensitiveStr::Ascii("ratios"), - dictgen::InsensitiveStr::Ascii("ratons"), - dictgen::InsensitiveStr::Ascii("ratore"), - dictgen::InsensitiveStr::Ascii("ratos"), - dictgen::InsensitiveStr::Ascii("rats"), - dictgen::InsensitiveStr::Ascii("ratting"), - dictgen::InsensitiveStr::Ascii("relization"), - dictgen::InsensitiveStr::Ascii("relize"), - dictgen::InsensitiveStr::Ascii("relizing"), - dictgen::InsensitiveStr::Ascii("rocity"), - dictgen::InsensitiveStr::Ascii("roisty"), - dictgen::InsensitiveStr::Ascii("rostiy"), - dictgen::InsensitiveStr::Ascii("rsl"), - dictgen::InsensitiveStr::Ascii("ticaly"), - dictgen::InsensitiveStr::Ascii("ticlly"), + 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, + None, + 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: &[ - &["genealogical"], - &["genealogies"], - &["genealogy"], + &["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_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("ted"), + ], + values: &[ + &["generate"], + &["generated"], + &["generates"], + &["generating"], + &["generated"], + &["generic"], + &["generalization"], + &["generalize"], + &["generalizing"], + &["general"], + &["generally"], + &["generate"], + &["generated"], + &["generator"], + &["generating"], + &["generation"], + &["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("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("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"], &["generals"], &["generalize"], @@ -54814,36 +101160,90 @@ pub static WORD_GENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["generalization"], &["generalization"], &["generalizing"], + &["generally", "general"], &["generalize"], &["generally"], + &["generally"], + &["generalise"], &["generals"], &["generates"], &["generates"], - &["generates"], + &["generate", "general"], + &["generator"], + &["generates", "generators"], &["generate"], &["generate"], + &["generating"], &["generations"], &["generations"], &["generations"], &["generations"], &["generational"], &["generators"], + &["generating"], + &["generation", "generator"], &["generators"], &["generate"], &["generators"], &["generates"], &["generating"], - &["generalization"], - &["generalize"], - &["generalizing"], - &["generosity"], - &["generosity"], - &["generosity"], - &["generals"], - &["genetically"], - &["genetically"], ], - range: 3..=10, + 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"), + ], + values: &[ + &["general"], + &["generally"], + &["generated"], + &["generate"], + &["generated"], + &["generates"], + &["generating"], + &["generation"], + ], + range: 2..=5, }; static WORD_GENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54852,9 +101252,21 @@ static WORD_GENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_GENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tilia")], - values: &[&["genitalia"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("rate"), + dictgen::InsensitiveStr::Ascii("rated"), + dictgen::InsensitiveStr::Ascii("rating"), + dictgen::InsensitiveStr::Ascii("ration"), + dictgen::InsensitiveStr::Ascii("tilia"), + ], + values: &[ + &["generate"], + &["generated"], + &["generating"], + &["generation"], + &["genitalia"], + ], + range: 4..=6, }; static WORD_GEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -54863,125 +101275,117 @@ static WORD_GEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_GEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("oetry")], - values: &[&["geometry"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("etrical"), + dictgen::InsensitiveStr::Ascii("etry"), + dictgen::InsensitiveStr::Ascii("oetry"), + ], + values: &[&["geometrical"], &["geometry"], &["geometry"]], + range: 4..=7, }; -static WORD_GA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_GA_CHILDREN), +static WORD_GEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_GEE_CHILDREN), value: None, }; -pub static WORD_GA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_GEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("dgest"), - dictgen::InsensitiveStr::Ascii("gdets"), - dictgen::InsensitiveStr::Ascii("gnsters"), - dictgen::InsensitiveStr::Ascii("latic"), - dictgen::InsensitiveStr::Ascii("lations"), - dictgen::InsensitiveStr::Ascii("lcier"), - dictgen::InsensitiveStr::Ascii("ldiator"), - dictgen::InsensitiveStr::Ascii("llaxies"), - dictgen::InsensitiveStr::Ascii("lsgow"), - dictgen::InsensitiveStr::Ascii("lvinized"), - dictgen::InsensitiveStr::Ascii("memdoe"), - dictgen::InsensitiveStr::Ascii("mepaly"), - dictgen::InsensitiveStr::Ascii("meply"), - dictgen::InsensitiveStr::Ascii("merga"), - dictgen::InsensitiveStr::Ascii("mergat"), - dictgen::InsensitiveStr::Ascii("mifications"), - dictgen::InsensitiveStr::Ascii("mmeode"), - dictgen::InsensitiveStr::Ascii("nerate"), - dictgen::InsensitiveStr::Ascii("nes"), - dictgen::InsensitiveStr::Ascii("ngsterest"), - dictgen::InsensitiveStr::Ascii("ngsterous"), - dictgen::InsensitiveStr::Ascii("nkign"), - dictgen::InsensitiveStr::Ascii("nster"), - dictgen::InsensitiveStr::Ascii("rabge"), - dictgen::InsensitiveStr::Ascii("rantee"), - dictgen::InsensitiveStr::Ascii("ranteed"), - dictgen::InsensitiveStr::Ascii("rantees"), - dictgen::InsensitiveStr::Ascii("rdai"), - dictgen::InsensitiveStr::Ascii("rdient"), - dictgen::InsensitiveStr::Ascii("rfeild"), - dictgen::InsensitiveStr::Ascii("rfied"), - dictgen::InsensitiveStr::Ascii("rfiled"), - dictgen::InsensitiveStr::Ascii("rflied"), - dictgen::InsensitiveStr::Ascii("rnison"), - dictgen::InsensitiveStr::Ascii("rnola"), - dictgen::InsensitiveStr::Ascii("rrions"), - dictgen::InsensitiveStr::Ascii("rriosn"), - dictgen::InsensitiveStr::Ascii("rrsion"), - dictgen::InsensitiveStr::Ascii("ruantee"), - dictgen::InsensitiveStr::Ascii("ruanteed"), - dictgen::InsensitiveStr::Ascii("ruantees"), - dictgen::InsensitiveStr::Ascii("therig"), - dictgen::InsensitiveStr::Ascii("therins"), - dictgen::InsensitiveStr::Ascii("uarana"), - dictgen::InsensitiveStr::Ascii("untanamo"), - dictgen::InsensitiveStr::Ascii("untelt"), - dictgen::InsensitiveStr::Ascii("untelts"), - dictgen::InsensitiveStr::Ascii("untlent"), - dictgen::InsensitiveStr::Ascii("untlents"), - dictgen::InsensitiveStr::Ascii("untles"), - dictgen::InsensitiveStr::Ascii("untlettes"), - dictgen::InsensitiveStr::Ascii("urantee"), - dictgen::InsensitiveStr::Ascii("uranteed"), - dictgen::InsensitiveStr::Ascii("urantees"), - dictgen::InsensitiveStr::Ascii("urd"), - dictgen::InsensitiveStr::Ascii("urdian"), - dictgen::InsensitiveStr::Ascii("urding"), - dictgen::InsensitiveStr::Ascii("urentee"), - dictgen::InsensitiveStr::Ascii("urenteed"), - dictgen::InsensitiveStr::Ascii("urentees"), - dictgen::InsensitiveStr::Ascii("utnlet"), + 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: &[ - &["gadgets"], - &["gadgets"], - &["gangsters"], - &["galactic"], - &["galatians"], - &["glacier"], - &["gladiator"], - &["galaxies"], - &["glasgow"], - &["galvanized"], - &["gamemode"], - &["gameplay"], - &["gameplay"], - &["gamertag"], - &["gamertag"], - &["ramifications"], - &["gamemode"], &["generate"], - &["games"], - &["gangsters"], - &["gangsters"], - &["ganking"], - &["gangster"], - &["garbage"], - &["guarantee"], - &["guaranteed"], - &["guarantees"], - &["gardaí"], - &["gradient"], - &["garfield"], - &["garfield"], - &["garfield"], - &["garfield"], - &["garrison"], - &["granola"], - &["garrison"], - &["garrison"], - &["garrison"], - &["guarantee"], - &["guaranteed"], - &["guarantees"], - &["gatherings"], - &["gatherings"], + &["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), + None, + Some(&WORD_GAT_NODE), + Some(&WORD_GAU_NODE), + None, + None, + None, + None, + None, +]; + +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"], @@ -54991,16 +101395,233 @@ pub static WORD_GA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["gauntlets"], &["guarantee"], &["guaranteed"], + &["guaranteeing"], &["guarantees"], - &["guard"], + &["guard", "gourd"], &["guardian"], &["guarding"], &["guarantee"], &["guaranteed"], &["guarantees"], + &["gauss", "gauze"], + &["gaussian"], &["gauntlet"], ], - range: 3..=11, + 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"], + &["gatherings"], + &["gateway"], + ], + range: 3..=6, +}; + +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("antees"), + dictgen::InsensitiveStr::Ascii("antied"), + 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("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"], + &["guarantees"], + &["guaranteed"], + &["guarantee"], + &["garbage"], + &["garbage"], + &["garbage"], + &["guard"], + &["gardaí"], + &["gradient"], + &["guarantee"], + &["garfield"], + &["garfield"], + &["garfield"], + &["garfield"], + &["garbage", "garage"], + &["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("es"), + dictgen::InsensitiveStr::Ascii("gsterest"), + dictgen::InsensitiveStr::Ascii("gsterous"), + dictgen::InsensitiveStr::Ascii("kign"), + dictgen::InsensitiveStr::Ascii("ster"), + ], + values: &[ + &["gambia"], + &["generate"], + &["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("sgow"), + dictgen::InsensitiveStr::Ascii("vinized"), + ], + values: &[ + &["galactic"], + &["galatians"], + &["glacier"], + &["gladiator"], + &["galleries"], + &["gallery"], + &["galaxies"], + &["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("nsters"), + ], + values: &[&["gadgets"], &["gangsters"]], + range: 4..=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 { @@ -55011,12 +101632,12 @@ static WORD_F_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_FA_NODE), None, - None, + Some(&WORD_FC_NODE), None, Some(&WORD_FE_NODE), None, None, - None, + Some(&WORD_FH_NODE), Some(&WORD_FI_NODE), None, None, @@ -55024,28 +101645,58 @@ static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_FN_NODE), Some(&WORD_FO_NODE), - None, + Some(&WORD_FP_NODE), None, Some(&WORD_FR_NODE), - None, - None, + Some(&WORD_FS_NODE), + Some(&WORD_FT_NODE), Some(&WORD_FU_NODE), None, Some(&WORD_FW_NODE), - None, - None, + 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")], - values: &[&["frankenstein"]], - range: 10..=10, + 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 { @@ -55054,13 +101705,13 @@ static WORD_FU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_FUA_NODE), None, Some(&WORD_FUC_NODE), None, None, Some(&WORD_FUF_NODE), - None, + Some(&WORD_FUG_NODE), None, None, None, @@ -55072,7 +101723,7 @@ static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_FUR_NODE), - None, + Some(&WORD_FUS_NODE), Some(&WORD_FUT_NODE), None, None, @@ -55089,9 +101740,14 @@ static WORD_FUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"), @@ -55102,9 +101758,14 @@ pub static WORD_FUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("urustic"), ], values: &[ + &["further"], + &["further"], &["further"], &["furthermore"], - &["futhark"], + &["futhark", "futhorc"], + &["future"], + &["future"], + &["future"], &["futures"], &["futuristic"], &["futures"], @@ -55114,7 +101775,22 @@ pub static WORD_FUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["futuristic"], &["futuristic"], ], - range: 3..=9, + 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("hed"), + dictgen::InsensitiveStr::Ascii("hing"), + ], + values: &[&["fuchsia"], &["flushed"], &["flushing"]], + range: 3..=4, }; static WORD_FUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -55126,38 +101802,96 @@ pub static WORD_FUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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("ter"), + dictgen::InsensitiveStr::Ascii("themore"), + dictgen::InsensitiveStr::Ascii("thermor"), dictgen::InsensitiveStr::Ascii("thremore"), + 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"], + &["furniture"], + &["further"], + &["furthermore"], + &["first", "furthest"], + &["first"], + &["further"], + &["furthermore"], + &["furthest"], &["frustrated"], &["frustrates"], &["frustration"], &["frustrations"], + &["further"], + &["furthermore"], &["furthermore"], &["furthermore"], &["further"], + &["furthermore"], + &["future"], + &["future"], + &["fruit", "future"], + &["further"], &["futuristic"], + &["future"], + &["fuzzer"], ], - range: 4..=9, + range: 2..=9, }; static WORD_FUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -55172,11 +101906,11 @@ static WORD_FUN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_FUND_NODE), None, None, - None, + Some(&WORD_FUNG_NODE), None, Some(&WORD_FUNI_NODE), None, - None, + Some(&WORD_FUNK_NODE), None, None, Some(&WORD_FUNN_NODE), @@ -55200,9 +101934,29 @@ static WORD_FUNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_FUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ion")], - values: &[&["function"]], - range: 3..=3, + 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"), + ], + values: &[ + &["function"], + &["functional"], + &["functionalities"], + &["functionality"], + &["functionality"], + &["functionally"], + &["functionality"], + &["functioning"], + &["functions"], + ], + range: 3..=10, }; static WORD_FUNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -55214,8 +101968,20 @@ pub static WORD_FUNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("iliy"), dictgen::InsensitiveStr::Ascii("illy"), + dictgen::InsensitiveStr::Ascii("nily"), ], - values: &[&["funnily"], &["funnily"]], + 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, }; @@ -55230,6 +101996,17 @@ pub static WORD_FUNI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -55266,6 +102043,7 @@ pub static WORD_FUND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("amnetalist"), dictgen::InsensitiveStr::Ascii("amnetalists"), dictgen::InsensitiveStr::Ascii("amnetally"), + dictgen::InsensitiveStr::Ascii("ation"), dictgen::InsensitiveStr::Ascii("emantal"), dictgen::InsensitiveStr::Ascii("emantalist"), dictgen::InsensitiveStr::Ascii("emantalists"), @@ -55312,6 +102090,7 @@ pub static WORD_FUND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["fundamentalist"], &["fundamentalists"], &["fundamentally"], + &["foundation"], &["fundamental"], &["fundamentalist"], &["fundamentalists"], @@ -55338,44 +102117,110 @@ static WORD_FUNC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_FUNC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("htion"), + dictgen::InsensitiveStr::Ascii("htional"), + dictgen::InsensitiveStr::Ascii("htioned"), + dictgen::InsensitiveStr::Ascii("htioning"), + dictgen::InsensitiveStr::Ascii("htionn"), + dictgen::InsensitiveStr::Ascii("htionnal"), + dictgen::InsensitiveStr::Ascii("htionned"), + dictgen::InsensitiveStr::Ascii("htionning"), + dictgen::InsensitiveStr::Ascii("htionns"), + dictgen::InsensitiveStr::Ascii("htions"), + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("ions"), dictgen::InsensitiveStr::Ascii("iton"), dictgen::InsensitiveStr::Ascii("itonal"), dictgen::InsensitiveStr::Ascii("itonality"), dictgen::InsensitiveStr::Ascii("itonally"), + dictgen::InsensitiveStr::Ascii("itoned"), dictgen::InsensitiveStr::Ascii("itoning"), dictgen::InsensitiveStr::Ascii("itons"), + dictgen::InsensitiveStr::Ascii("tin"), + dictgen::InsensitiveStr::Ascii("tinality"), + dictgen::InsensitiveStr::Ascii("tino"), + dictgen::InsensitiveStr::Ascii("tins"), + dictgen::InsensitiveStr::Ascii("tionability"), dictgen::InsensitiveStr::Ascii("tionable"), dictgen::InsensitiveStr::Ascii("tionailty"), dictgen::InsensitiveStr::Ascii("tionaliy"), dictgen::InsensitiveStr::Ascii("tionallity"), + dictgen::InsensitiveStr::Ascii("tionaltiy"), dictgen::InsensitiveStr::Ascii("tionalty"), dictgen::InsensitiveStr::Ascii("tionaly"), dictgen::InsensitiveStr::Ascii("tiong"), dictgen::InsensitiveStr::Ascii("tionlity"), dictgen::InsensitiveStr::Ascii("tionnal"), + dictgen::InsensitiveStr::Ascii("tionnalities"), + dictgen::InsensitiveStr::Ascii("tionnality"), + dictgen::InsensitiveStr::Ascii("tionnaly"), dictgen::InsensitiveStr::Ascii("tionning"), + dictgen::InsensitiveStr::Ascii("tionon"), + dictgen::InsensitiveStr::Ascii("tionss"), + dictgen::InsensitiveStr::Ascii("tios"), + dictgen::InsensitiveStr::Ascii("tiosn"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tonal"), + dictgen::InsensitiveStr::Ascii("tonality"), + dictgen::InsensitiveStr::Ascii("toning"), + dictgen::InsensitiveStr::Ascii("tons"), dictgen::InsensitiveStr::Ascii("ttion"), + dictgen::InsensitiveStr::Ascii("zion"), ], values: &[ + &["function"], &["function"], &["functional"], - &["functionality"], - &["functionally"], - &["functioning"], - &["functions"], - &["functional"], - &["functionality"], - &["functionally"], - &["functionality"], - &["functionality"], - &["functionally"], - &["functioning"], - &["functionality"], - &["functional"], + &["functioned"], &["functioning"], &["function"], + &["functional"], + &["functioned"], + &["functioning"], + &["functions"], + &["functions"], + &["function"], + &["functions"], + &["function"], + &["functional"], + &["functionality"], + &["functionally"], + &["functioned"], + &["functioning"], + &["functions"], + &["function"], + &["functionality"], + &["function"], + &["functions"], + &["functionality"], + &["functional", "functioning"], + &["functionality"], + &["functionally"], + &["functionality"], + &["functionality"], + &["functionality"], + &["functionally"], + &["functioning"], + &["functionality"], + &["functional"], + &["functionalities"], + &["functionality"], + &["functionally"], + &["functioning"], + &["function"], + &["functions"], + &["functions"], + &["functions"], + &["function"], + &["functional"], + &["functionality"], + &["functioning"], + &["functions"], + &["function"], + &["function"], ], - range: 4..=10, + range: 3..=12, }; static WORD_FUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -55385,38 +102230,71 @@ static WORD_FUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), ], values: &[ + &["file"], &["fulfilled"], &["fulfilling"], &["fulfilling"], &["fulfillment"], &["fullest"], - &["fulfilling"], - &["fulfill"], + &["fulfil", "fulfil"], &["fulfilled"], + &["fulfilling"], + &["fulfill", "fulfill"], + &["fulfilled"], + &["fulfilling"], + &["fulfills"], &["fulfilment"], + &["fulfils", "fulfils"], + &["fulfill", "fulfill"], + &["fully"], &["fullscreen"], &["fullscreen"], &["fullscreen"], &["fullest"], + &["flush"], &["fluttershy"], ], - range: 4..=8, + 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 { @@ -55446,6 +102324,9 @@ pub static WORD_FUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ntionally"), dictgen::InsensitiveStr::Ascii("ntioning"), dictgen::InsensitiveStr::Ascii("ntions"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tionoid"), + dictgen::InsensitiveStr::Ascii("tions"), ], values: &[ &["function"], @@ -55454,8 +102335,47 @@ pub static WORD_FUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["functionally"], &["functioning"], &["functions"], + &["function"], + &["functionoid"], + &["functions"], ], - range: 5..=10, + 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("runacate")], + values: &[&["ftruncate"]], + range: 8..=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 { @@ -55470,13 +102390,13 @@ static WORD_FR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_FRE_NODE), None, - None, + Some(&WORD_FRG_NODE), None, Some(&WORD_FRI_NODE), None, None, None, - None, + Some(&WORD_FRM_NODE), None, Some(&WORD_FRO_NODE), None, @@ -55563,46 +102483,88 @@ static WORD_FRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("mation"), dictgen::InsensitiveStr::Ascii("matting"), dictgen::InsensitiveStr::Ascii("me"), dictgen::InsensitiveStr::Ascii("med"), dictgen::InsensitiveStr::Ascii("merly"), dictgen::InsensitiveStr::Ascii("midable"), + dictgen::InsensitiveStr::Ascii("ms"), + dictgen::InsensitiveStr::Ascii("n"), + 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("zee"), ], values: &[ + &["force"], &["forgiven"], &["frontier"], + &["from"], + &["formal"], + &["format"], &["formation"], &["formatting"], &["from"], &["formed"], &["formerly"], &["formidable"], + &["forms"], + &["from"], + &["frontend"], + &["frontends"], &["frontier"], &["frankenstein"], &["frontpage"], &["frontier"], + &["frontend"], + &["frontends"], &["frontline"], &["frontline"], &["frontline"], &["frontline"], + &["drop"], + &["from"], + &["drops"], &["forsaken"], &["frosting"], + &["frozen"], ], - range: 2..=9, + 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 { @@ -55612,6 +102574,7 @@ static WORD_FRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cton"), dictgen::InsensitiveStr::Ascii("ednship"), dictgen::InsensitiveStr::Ascii("ednzone"), dictgen::InsensitiveStr::Ascii("endboned"), @@ -55640,9 +102603,11 @@ pub static WORD_FRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("mware"), dictgen::InsensitiveStr::Ascii("nedzoned"), dictgen::InsensitiveStr::Ascii("ngeworthy"), + dictgen::InsensitiveStr::Ascii("st"), dictgen::InsensitiveStr::Ascii("stly"), ], values: &[ + &["friction"], &["friendships"], &["friendzoned"], &["friendzoned"], @@ -55671,9 +102636,21 @@ pub static WORD_FRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["firmware"], &["friendzoned"], &["cringeworthy"], + &["first"], &["firstly"], ], - range: 4..=10, + 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 { @@ -55685,12 +102662,25 @@ pub static WORD_FRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("edomers"), dictgen::InsensitiveStr::Ascii("edomes"), dictgen::InsensitiveStr::Ascii("edomest"), + dictgen::InsensitiveStr::Ascii("edon"), + dictgen::InsensitiveStr::Ascii("edons"), dictgen::InsensitiveStr::Ascii("edos"), + 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"), @@ -55700,25 +102690,51 @@ pub static WORD_FRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("indzoned"), dictgen::InsensitiveStr::Ascii("mentation"), dictgen::InsensitiveStr::Ascii("mented"), + dictgen::InsensitiveStr::Ascii("qencies"), + dictgen::InsensitiveStr::Ascii("qency"), dictgen::InsensitiveStr::Ascii("qeuncy"), + 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"], &["freedoms"], &["freedoms"], &["freedoms"], + &["freedom"], &["freedoms"], + &["freedoms"], + &["free"], + &["freed"], &["freestyle"], &["freestyle"], + &["frees", "freeze"], + &["freezes"], &["friend"], &["friendlies"], &["friendly"], @@ -55728,80 +102744,285 @@ pub static WORD_FRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["friendzoned"], &["fermentation"], &["fermented"], + &["frequencies"], + &["frequency"], &["frequency"], &["frequencies"], &["frequency"], + &["frequent"], + &["frequently"], + &["frequencies"], + &["frequencies"], + &["frequency"], + &["frequency", "frequent"], + &["frequencies"], &["frequencies"], &["frequencies"], &["frequencies"], &["frequently"], - &["frequency"], + &["frequency", "frequently", "frequent"], &["frequencies"], + &["frequencies"], + &["frequency"], + &["freeze"], + &["freezes"], ], - range: 3..=9, + range: 2..=10, }; static WORD_FRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_FRA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_FRA_CHILDREN), value: None, }; -pub static WORD_FRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ckign"), - dictgen::InsensitiveStr::Ascii("ctalers"), - dictgen::InsensitiveStr::Ascii("ctales"), - dictgen::InsensitiveStr::Ascii("ctalis"), - dictgen::InsensitiveStr::Ascii("ctalius"), - dictgen::InsensitiveStr::Ascii("ctalpus"), - dictgen::InsensitiveStr::Ascii("ctalus"), - dictgen::InsensitiveStr::Ascii("cter"), - dictgen::InsensitiveStr::Ascii("cturare"), - dictgen::InsensitiveStr::Ascii("gement"), - dictgen::InsensitiveStr::Ascii("gmanted"), - dictgen::InsensitiveStr::Ascii("gmenot"), - dictgen::InsensitiveStr::Ascii("gmet"), - dictgen::InsensitiveStr::Ascii("methrower"), - dictgen::InsensitiveStr::Ascii("mgent"), - dictgen::InsensitiveStr::Ascii("ncaises"), - dictgen::InsensitiveStr::Ascii("nches"), - dictgen::InsensitiveStr::Ascii("nchices"), - dictgen::InsensitiveStr::Ascii("nchie"), - dictgen::InsensitiveStr::Ascii("nchies"), - dictgen::InsensitiveStr::Ascii("nchieses"), - dictgen::InsensitiveStr::Ascii("nchines"), - dictgen::InsensitiveStr::Ascii("nchizes"), - dictgen::InsensitiveStr::Ascii("nchsies"), - dictgen::InsensitiveStr::Ascii("nciso"), - dictgen::InsensitiveStr::Ascii("ncsico"), - dictgen::InsensitiveStr::Ascii("nkensite"), - dictgen::InsensitiveStr::Ascii("nkenstain"), - dictgen::InsensitiveStr::Ascii("nkensteen"), - dictgen::InsensitiveStr::Ascii("nkensten"), - dictgen::InsensitiveStr::Ascii("nkenstiens"), - dictgen::InsensitiveStr::Ascii("nkenstine"), - dictgen::InsensitiveStr::Ascii("nkenstined"), - dictgen::InsensitiveStr::Ascii("nkenstiner"), - dictgen::InsensitiveStr::Ascii("nkenstines"), - dictgen::InsensitiveStr::Ascii("nkiln"), - dictgen::InsensitiveStr::Ascii("nkinstein"), - dictgen::InsensitiveStr::Ascii("nlkin"), - dictgen::InsensitiveStr::Ascii("nscico"), - dictgen::InsensitiveStr::Ascii("nsiscan"), - dictgen::InsensitiveStr::Ascii("nsiscans"), - dictgen::InsensitiveStr::Ascii("nticaly"), - dictgen::InsensitiveStr::Ascii("nticlly"), - dictgen::InsensitiveStr::Ascii("ternaty"), - dictgen::InsensitiveStr::Ascii("ternety"), - dictgen::InsensitiveStr::Ascii("terntiy"), - dictgen::InsensitiveStr::Ascii("turnity"), - dictgen::InsensitiveStr::Ascii("udalent"), - dictgen::InsensitiveStr::Ascii("udelant"), - dictgen::InsensitiveStr::Ascii("udelent"), - dictgen::InsensitiveStr::Ascii("udolent"), - dictgen::InsensitiveStr::Ascii("udulant"), + 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("ethrower"), + dictgen::InsensitiveStr::Ascii("etyp"), + dictgen::InsensitiveStr::Ascii("eworkk"), + dictgen::InsensitiveStr::Ascii("gent"), + dictgen::InsensitiveStr::Ascii("layout"), + dictgen::InsensitiveStr::Ascii("ming"), + dictgen::InsensitiveStr::Ascii("wework"), + dictgen::InsensitiveStr::Ascii("work"), + dictgen::InsensitiveStr::Ascii("works"), + ], + values: &[ + &["framebuffer"], + &["framebuffer"], + &["frame"], + &["flamethrower"], + &["frametype"], + &["framework"], + &["fragment"], + &["framelayout"], + &["framing"], + &["framework"], + &["framework"], + &["frameworks"], + ], + range: 2..=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"], @@ -55811,79 +103032,50 @@ pub static WORD_FRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fractals"], &["fracture"], &["fracture"], - &["fragment"], - &["fragment"], - &["fragment"], - &["fragment"], - &["flamethrower"], - &["fragment"], - &["franchises"], - &["franchise"], - &["franchises"], - &["franchises"], - &["franchise"], - &["franchises"], - &["franchises"], - &["franchises"], - &["franchises"], - &["francisco"], - &["francisco"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["frankenstein"], - &["franklin"], - &["frankenstein"], - &["franklin"], - &["francisco"], - &["franciscan"], - &["franciscans"], - &["frantically"], - &["frantically"], - &["fraternity"], - &["fraternity"], - &["fraternity"], - &["fraternity"], - &["fraudulent"], - &["fraudulent"], - &["fraudulent"], - &["fraudulent"], - &["fraudulent"], ], - range: 4..=10, + 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"), + ], + values: &[&["for", "far", "fps"], &["format"]], + range: 1..=4, }; static WORD_FO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_FO_CHILDREN), - value: None, + value: Some(&["of", "for"]), }; static WORD_FO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ None, None, + Some(&WORD_FOC_NODE), None, None, + Some(&WORD_FOF_NODE), + Some(&WORD_FOG_NODE), None, - None, - None, - None, - None, + Some(&WORD_FOI_NODE), None, None, Some(&WORD_FOL_NODE), Some(&WORD_FOM_NODE), Some(&WORD_FON_NODE), Some(&WORD_FOO_NODE), - None, + Some(&WORD_FOP_NODE), None, Some(&WORD_FOR_NODE), Some(&WORD_FOS_NODE), - None, + Some(&WORD_FOT_NODE), Some(&WORD_FOU_NODE), None, Some(&WORD_FOW_NODE), @@ -55900,10 +103092,19 @@ static WORD_FOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("rards"), ], - values: &[&["forward"], &["forwards"]], - range: 3..=5, + values: &[ + &["forward"], + &["forwarded"], + &["forwarding"], + &["forwards"], + &["forwards"], + ], + range: 3..=6, }; static WORD_FOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -55915,12 +103116,16 @@ pub static WORD_FOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("rteeen"), @@ -55932,12 +103137,16 @@ pub static WORD_FOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["focus"], &["found"], + &["founding"], &["fought"], + &["fault"], + &["faults"], &["foundations"], &["foundries"], &["foundry"], &["foundations"], &["foundations"], + &["newfoundland"], &["fountain"], &["fountain"], &["fourteen"], @@ -55949,6 +103158,33 @@ pub static WORD_FOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -55980,7 +103216,7 @@ static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_FORI_NODE), None, None, - None, + Some(&WORD_FORL_NODE), Some(&WORD_FORM_NODE), Some(&WORD_FORN_NODE), None, @@ -55990,13 +103226,53 @@ static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_FORS_NODE), Some(&WORD_FORT_NODE), Some(&WORD_FORU_NODE), - None, - None, + 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, @@ -56004,13 +103280,34 @@ static WORD_FORU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["formulate"], &["forerunner"]], - range: 3..=5, + 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 { @@ -56020,13 +103317,20 @@ static WORD_FORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -56035,7 +103339,12 @@ pub static WORD_FORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("unte"), ], values: &[ + &["fortran"], + &["format"], + &["fourteen"], &["foretelling"], + &["forthcoming"], + &["forthcoming"], &["fortitude"], &["fortitude"], &["fortunate"], @@ -56043,13 +103352,15 @@ pub static WORD_FORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["fortune"], &["fortunately"], &["fortunately"], + &["fortunate"], + &["fortunately"], &["fortunately"], &["fortunately"], &["fortunately"], &["fortunately"], &["fortune"], ], - range: 4..=8, + range: 2..=8, }; static WORD_FORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56062,30 +103373,34 @@ pub static WORD_FORS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: 2..=6, + range: 1..=6, }; static WORD_FORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_FORR_CHILDREN), - value: None, + value: Some(&["for"]), }; pub static WORD_FORR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -56125,14 +103440,25 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ates"), 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("attind"), + dictgen::InsensitiveStr::Ascii("attted"), dictgen::InsensitiveStr::Ascii("attting"), dictgen::InsensitiveStr::Ascii("elly"), + dictgen::InsensitiveStr::Ascii("ely"), + 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"), @@ -56141,7 +103467,10 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("uals"), dictgen::InsensitiveStr::Ascii("ualte"), @@ -56157,15 +103486,26 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["formally"], &["formalize"], &["formalized"], - &["formally"], + &["formally", "formerly"], + &["format"], + &["formatted"], + &["formatter"], + &["formats"], &["formatting"], &["formation"], + &["formatting"], &["formations"], &["formations"], + &["formatted"], + &["formatting"], + &["formatted"], &["formatting"], &["formerly"], &["formerly"], + &["formed"], &["formerly"], + &["formerly"], + &["forms", "formed"], &["formidable"], &["formidable"], &["formidable"], @@ -56174,7 +103514,10 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["formidable"], &["formidable"], &["formidable"], + &["formatted"], &["foremost"], + &["format"], + &["formula"], &["formula"], &["formulas"], &["formulate"], @@ -56184,7 +103527,22 @@ pub static WORD_FORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["formulas"], &["formulas"], ], - range: 3..=7, + 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 { @@ -56232,6 +103590,7 @@ pub static WORD_FORG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -56240,11 +103599,14 @@ pub static WORD_FORG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ivens"), dictgen::InsensitiveStr::Ascii("ivenss"), dictgen::InsensitiveStr::Ascii("iviness"), + dictgen::InsensitiveStr::Ascii("oten"), dictgen::InsensitiveStr::Ascii("otting"), + dictgen::InsensitiveStr::Ascii("round"), ], values: &[ &["foreigner"], &["foreigners"], + &["foreground"], &["forgetting"], &["foreigner"], &["foreigners"], @@ -56253,9 +103615,11 @@ pub static WORD_FORG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["forgiveness"], &["forgiveness"], &["forgiveness"], + &["forgotten"], &["forgetting"], + &["foreground"], ], - range: 5..=8, + range: 4..=8, }; static WORD_FORF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56292,6 +103656,7 @@ pub static WORD_FORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -56319,6 +103684,7 @@ pub static WORD_FORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["foreigner"], &["foreigners"], &["foreskin"], + &["aforementioned"], &["forensic"], &["forensic"], &["forensic"], @@ -56327,7 +103693,7 @@ pub static WORD_FORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["foreshadowing"], &["forensic"], &["foreseeable"], - &["foreword"], + &["foreword", "forward"], ], range: 3..=10, }; @@ -56339,20 +103705,24 @@ static WORD_FORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_FORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ably"), 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"], &["forcefully"], &["forcefully"], &["forcibly"], &["forcibly"], &["forcefully"], + &["forgot"], ], - range: 5..=7, + range: 2..=7, }; static WORD_FORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56361,9 +103731,23 @@ static WORD_FORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_FORB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iden")], - values: &[&["forbidden"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ad"), + dictgen::InsensitiveStr::Ascii("biden"), + dictgen::InsensitiveStr::Ascii("iden"), + dictgen::InsensitiveStr::Ascii("it"), + dictgen::InsensitiveStr::Ascii("iten"), + dictgen::InsensitiveStr::Ascii("itten"), + ], + values: &[ + &["forbade"], + &["forbidden"], + &["forbidden"], + &["forbid"], + &["forbidden"], + &["forbidden"], + ], + range: 2..=5, }; static WORD_FORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56372,9 +103756,28 @@ static WORD_FORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_FORA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sken")], - values: &[&["forsaken"]], - range: 4..=4, + 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 { @@ -56383,9 +103786,14 @@ static WORD_FOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_FOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("otball")], - values: &[&["football"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("ntnotes"), + dictgen::InsensitiveStr::Ascii("otball"), + dictgen::InsensitiveStr::Ascii("rter"), + dictgen::InsensitiveStr::Ascii("tnoes"), + ], + values: &[&["footnotes"], &["football"], &["footer"], &["footnotes"]], + range: 4..=7, }; static WORD_FON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56395,20 +103803,46 @@ static WORD_FON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("tonfig"), dictgen::InsensitiveStr::Ascii("trier"), + dictgen::InsensitiveStr::Ascii("ud"), ], values: &[ + &["function"], + &["functional"], + &["functionalities"], + &["functioning"], + &["functionalities"], + &["functionalities"], + &["functionality"], + &["functionally", "functionality"], + &["functions"], &["fundamentalist"], &["fundamentalists"], &["phonetic"], + &["fountain", "contain"], + &["fountains", "contains"], &["frontier"], + &["fontconfig"], &["frontier"], + &["found"], ], - range: 4..=12, + range: 2..=13, }; static WORD_FOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56419,25 +103853,705 @@ static WORD_FOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), ], - values: &[&["foaming"], &["formed"], &["from"]], - range: 1..=4, + values: &[ + &["foaming"], + &["format"], + &["formatted"], + &["formatter"], + &["formats"], + &["formatting"], + &["formats"], + &["formatted"], + &["formatter"], + &["formed"], + &["from", "form"], + &["format"], + &["formatted"], + &["formatter"], + &["formatting"], + &["formats"], + &["formatted"], + &["formatter"], + &["formatting"], + ], + range: 1..=7, }; static WORD_FOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_FOL_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_FOL_CHILDREN), value: None, }; -pub static WORD_FOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("lwoing"), - dictgen::InsensitiveStr::Ascii("owing"), + 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: &[&["following"], &["following"]], - range: 5..=6, + 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, + None, + 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("ng"), + dictgen::InsensitiveStr::Ascii("wd"), + dictgen::InsensitiveStr::Ascii("wig"), + dictgen::InsensitiveStr::Ascii("wign"), + dictgen::InsensitiveStr::Ascii("win"), + dictgen::InsensitiveStr::Ascii("wind"), + dictgen::InsensitiveStr::Ascii("wng"), + ], + values: &[ + &["followed"], + &["following"], + &["following"], + &["following"], + &["following"], + &["followed", "follows", "follow"], + &["following"], + &["following"], + &["following"], + &["following"], + &["following"], + ], + range: 1..=4, +}; + +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_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("ot"), + dictgen::InsensitiveStr::Ascii("otten"), + ], + values: &[&["forget"], &["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_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 { @@ -56476,15 +104590,26 @@ static WORD_FL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, + Some(&WORD_FLT_NODE), Some(&WORD_FLU_NODE), None, 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, @@ -56500,8 +104625,13 @@ pub static WORD_FLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -56518,8 +104648,13 @@ pub static WORD_FLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fluctuate"], &["fluctuate"], &["fluctuations"], + &["flood"], &["flourish"], + &["fluorescent"], + &["fluorescent"], &["fluoride"], + &["flushes"], + &["flushing"], &["fluttershy"], &["fluttershy"], &["fluttershy"], @@ -56527,7 +104662,18 @@ pub static WORD_FLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fluttershy"], &["fluctuations"], ], - range: 5..=9, + 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 { @@ -56537,25 +104683,35 @@ static WORD_FLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ading"), 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"], &["florida"], &["florence"], &["florence"], + &["fluorescent", "florescent"], + &["fluoride"], &["florida"], &["fluoride"], &["flourish"], - &["fluorescent"], + &["floating"], + &["fluorescent", "florescent"], + &["fluoride"], &["fluorine"], &["flourishing"], &["flourish"], @@ -56570,18 +104726,25 @@ static WORD_FLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("tered"), dictgen::InsensitiveStr::Ascii("ters"), ], - values: &[&["filmmakers"], &["flipped"], &["filtered"], &["filters"]], - range: 4..=7, + values: &[ + &["file"], + &["filmmakers"], + &["flipped"], + &["filtered"], + &["filters"], + ], + range: 1..=7, }; static WORD_FLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_FLE_CHILDREN), - value: None, + value: Some(&["file"]), }; pub static WORD_FLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -56589,22 +104752,33 @@ pub static WORD_FLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("xt"), ], values: &[ &["fletcher"], &["fletcher"], - &["fled"], + &["fled", "freed"], + &["phlegm"], &["flemish"], &["fletcher"], + &["fluent"], + &["flexibility"], + &["flexible"], + &["flexible"], &["flexible"], &["flexible"], &["flexibility"], @@ -56612,8 +104786,9 @@ pub static WORD_FLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["flexibility"], &["flexibility"], &["flexibility"], + &["flex"], ], - range: 2..=9, + range: 1..=9, }; static WORD_FLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56635,20 +104810,46 @@ static WORD_FLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -56667,20 +104868,46 @@ pub static WORD_FLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], 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"], &["falsely"], &["flagship"], + &["flashframe"], &["flashing"], &["flashlight"], &["flashlight"], + &["flashing"], &["flashbacks"], + &["class", "glass", "flask", "flash"], + &["flat"], + &["flattened"], + &["flattened"], + &["flattening"], &["flattered"], &["flattered"], &["flatter"], @@ -56697,7 +104924,7 @@ pub static WORD_FLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["flawlessly"], &["flawlessly"], ], - range: 4..=9, + range: 2..=9, }; static WORD_FI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56716,33 +104943,86 @@ static WORD_FI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, + Some(&WORD_FIK_NODE), Some(&WORD_FIL_NODE), Some(&WORD_FIM_NODE), Some(&WORD_FIN_NODE), - None, + 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, - None, - None, - 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("eme"), + dictgen::InsensitiveStr::Ascii("wd"), + ], + values: &[ + &["fixed", "fixes", "fix", "fixme", "fixer"], + &["fixme"], + &["fixed"], + ], + range: 1..=3, +}; + +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("lers")], - values: &[&["filters"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("ering"), + dictgen::InsensitiveStr::Ascii("ers"), + dictgen::InsensitiveStr::Ascii("ler"), + dictgen::InsensitiveStr::Ascii("lers"), + ], + values: &[ + &["filter", "fighter", "fitter", "fiver"], + &["filtering"], + &["filters", "fighters", "fitters", "fivers"], + &["filter"], + &["filters"], + ], + range: 2..=5, }; static WORD_FIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56751,9 +105031,21 @@ static WORD_FIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_FIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ionable")], - values: &[&["fissionable"]], - range: 7..=7, + 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 { @@ -56763,6 +105055,7 @@ static WORD_FIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("dt"), dictgen::InsensitiveStr::Ascii("eballls"), dictgen::InsensitiveStr::Ascii("ebals"), dictgen::InsensitiveStr::Ascii("efigher"), @@ -56774,17 +105067,33 @@ pub static WORD_FIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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("sbee"), dictgen::InsensitiveStr::Ascii("slty"), + dictgen::InsensitiveStr::Ascii("sr"), + 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: &[ + &["first", "third"], &["fireballs"], &["fireballs"], &["firefighter"], @@ -56796,64 +105105,200 @@ pub static WORD_FIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["friendly"], &["friends"], &["friendzoned"], + &["fires", "first"], + &["fiery"], &["friggin"], &["frightened"], &["frightening"], &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], + &["firmware"], &["frisbee"], &["firstly"], - &["flirts"], + &["first"], + &["first"], + &["first", "flirt"], + &["flirts", "first"], &["firstly"], &["firmware"], + &["firmware"], ], - range: 2..=9, + range: 1..=9, }; -static WORD_FIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_FIN_CHILDREN), +static WORD_FIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_FIO_CHILDREN), value: None, }; -pub static WORD_FIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("acee"), - dictgen::InsensitiveStr::Ascii("acial"), - dictgen::InsensitiveStr::Ascii("allizes"), - dictgen::InsensitiveStr::Ascii("aly"), - dictgen::InsensitiveStr::Ascii("ancialy"), - dictgen::InsensitiveStr::Ascii("anically"), - dictgen::InsensitiveStr::Ascii("antially"), - dictgen::InsensitiveStr::Ascii("eses"), - dictgen::InsensitiveStr::Ascii("eshes"), - dictgen::InsensitiveStr::Ascii("gernal"), - dictgen::InsensitiveStr::Ascii("gernals"), - dictgen::InsensitiveStr::Ascii("gerpies"), - dictgen::InsensitiveStr::Ascii("gerpint"), - dictgen::InsensitiveStr::Ascii("gerpints"), - dictgen::InsensitiveStr::Ascii("gerpoint"), - dictgen::InsensitiveStr::Ascii("gerpoints"), - dictgen::InsensitiveStr::Ascii("gersi"), - dictgen::InsensitiveStr::Ascii("gertaps"), - dictgen::InsensitiveStr::Ascii("gertits"), - dictgen::InsensitiveStr::Ascii("gertops"), - dictgen::InsensitiveStr::Ascii("gertrips"), - dictgen::InsensitiveStr::Ascii("insh"), - dictgen::InsensitiveStr::Ascii("ishs"), - dictgen::InsensitiveStr::Ascii("isse"), - dictgen::InsensitiveStr::Ascii("nisch"), - dictgen::InsensitiveStr::Ascii("nsih"), - dictgen::InsensitiveStr::Ascii("sihes"), + 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: &[ - &["fiancee"], - &["financial"], + &["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("alizing"), + dictgen::InsensitiveStr::Ascii("lizes"), + dictgen::InsensitiveStr::Ascii("nsh"), + dictgen::InsensitiveStr::Ascii("sch"), + dictgen::InsensitiveStr::Ascii("sched"), + dictgen::InsensitiveStr::Ascii("she"), + dictgen::InsensitiveStr::Ascii("shied"), + dictgen::InsensitiveStr::Ascii("shs"), + dictgen::InsensitiveStr::Ascii("sse"), + dictgen::InsensitiveStr::Ascii("tel"), + ], + values: &[ + &["finalization"], + &["finalizing"], &["finalizes"], - &["finally"], - &["financially"], - &["financially"], - &["financially"], - &["finesse"], - &["finesse"], + &["finnish"], + &["finish", "finnish"], + &["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"], @@ -56866,14 +105311,106 @@ pub static WORD_FIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fingertips"], &["fingertips"], &["fingertips"], - &["finnish"], - &["finishes"], - &["finishes"], - &["finnish"], - &["finnish"], - &["finishes"], ], - range: 3..=9, + 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("n"), + ], + values: &[&["find"], &["find"]], + range: 1..=1, +}; + +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("lle"), + dictgen::InsensitiveStr::Ascii("llizes"), + 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"], + &["finale", "finally"], + &["finalizes"], + &["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 { @@ -56882,9 +105419,19 @@ static WORD_FIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_FIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ilies")], - values: &[&["families"]], - range: 5..=5, + 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 { @@ -56894,32 +105441,131 @@ static WORD_FIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("eter"), dictgen::InsensitiveStr::Ascii("etimes"), + dictgen::InsensitiveStr::Ascii("eystem"), + dictgen::InsensitiveStr::Ascii("eystems"), dictgen::InsensitiveStr::Ascii("iament"), + 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("terring"), + dictgen::InsensitiveStr::Ascii("tersing"), + dictgen::InsensitiveStr::Ascii("terss"), ], values: &[ + &["final"], &["flicker"], &["fielding"], + &["fields"], + &["field"], + &["fields"], + &["filename"], + &["filename"], + &["filesystem"], + &["filesystems"], + &["filename", "filenames"], + &["filenames"], + &["files"], &["filesystem"], &["filesystem"], + &["filesystems"], + &["filesystem"], + &["filesystems"], + &["filesystem"], + &["filesystems"], + &["filesystems"], + &["filesystem"], + &["filesystems"], + &["filesystem"], + &["filesystem", "filesystems"], + &["filter"], &["lifetimes"], + &["filesystem"], + &["filesystems"], &["filament"], + &["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"], + &["filters"], ], - range: 4..=7, + 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 { @@ -56940,6 +105586,7 @@ pub static WORD_FIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("urativelly"), dictgen::InsensitiveStr::Ascii("urativley"), dictgen::InsensitiveStr::Ascii("urativly"), + dictgen::InsensitiveStr::Ascii("urestyle"), dictgen::InsensitiveStr::Ascii("uretively"), dictgen::InsensitiveStr::Ascii("uritively"), ], @@ -56955,6 +105602,7 @@ pub static WORD_FIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["figuratively"], &["figuratively"], &["figuratively"], + &["figurestyles"], &["figuratively"], &["figuratively"], ], @@ -56968,13 +105616,36 @@ static WORD_FIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("d"), dictgen::InsensitiveStr::Ascii("dling"), dictgen::InsensitiveStr::Ascii("dlity"), + 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"), ], - values: &[&["fielding"], &["fidelity"], &["fields"], &["fiercely"]], - range: 2..=5, + values: &[ + &["field"], + &["fielding"], + &["fidelity"], + &["field"], + &["feel", "field", "file", "phial"], + &["fieldlist"], + &["field"], + &["filesystem"], + &["filesystems"], + &["filename"], + &["filename"], + &["fields", "feels", "files", "phials"], + &["fiercely"], + ], + range: 1..=9, }; static WORD_FID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -56984,11 +105655,19 @@ static WORD_FID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["fielding"], &["fidelity"], &["find"]], + values: &[ + &["fidelity"], + &["fiddly"], + &["fielding"], + &["fidelity"], + &["find"], + ], range: 1..=5, }; @@ -56999,12 +105678,18 @@ static WORD_FIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ks"), dictgen::InsensitiveStr::Ascii("ticious"), dictgen::InsensitiveStr::Ascii("tionaries"), dictgen::InsensitiveStr::Ascii("tious"), ], - values: &[&["fictitious"], &["dictionaries"], &["fictitious"]], - range: 5..=9, + values: &[ + &["flicks", "fix"], + &["fictitious"], + &["dictionaries"], + &["fictitious"], + ], + range: 2..=9, }; static WORD_FIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57014,11 +105699,23 @@ static WORD_FIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["finite"], &["finally"]], - range: 4..=4, + 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 { @@ -57031,7 +105728,7 @@ static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_FEB_NODE), Some(&WORD_FEC_NODE), Some(&WORD_FED_NODE), - None, + Some(&WORD_FEE_NODE), None, None, None, @@ -57043,18 +105740,44 @@ static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_FEO_NODE), None, - None, + Some(&WORD_FEQ_NODE), Some(&WORD_FER_NODE), Some(&WORD_FES_NODE), Some(&WORD_FET_NODE), None, None, + Some(&WORD_FEW_NODE), None, None, - None, - 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_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, @@ -57062,20 +105785,28 @@ static WORD_FET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 4..=7, + range: 3..=7, }; static WORD_FES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57123,6 +105854,7 @@ pub static WORD_FER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -57142,6 +105874,7 @@ pub static WORD_FER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["pheromone"], &["fertilizer"], &["fertilizer"], + &["fertile"], &["fertilizer"], &["fertilizer"], &["fertility"], @@ -57149,7 +105882,18 @@ pub static WORD_FER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fertilizer"], &["fertilizer"], ], - range: 4..=9, + 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 { @@ -57158,8 +105902,11 @@ static WORD_FEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_FEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("dras")], - values: &[&["fedoras"]], + keys: &[ + dictgen::InsensitiveStr::Ascii("dras"), + dictgen::InsensitiveStr::Ascii("nsay"), + ], + values: &[&["fedoras"], &["fiancée"]], range: 4..=4, }; @@ -57183,6 +105930,7 @@ pub static WORD_FEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("insim"), dictgen::InsensitiveStr::Ascii("insits"), dictgen::InsensitiveStr::Ascii("minist"), + dictgen::InsensitiveStr::Ascii("pto"), ], values: &[ &["feminine"], @@ -57198,8 +105946,9 @@ pub static WORD_FEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["feminism"], &["feminists"], &["feminist"], + &["femto"], ], - range: 4..=8, + range: 3..=8, }; static WORD_FEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57209,6 +105958,8 @@ static WORD_FEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -57216,13 +105967,15 @@ pub static WORD_FEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("xible"), ], values: &[ + &["field"], + &["felicitous"], &["fellowship"], &["fellowship"], &["fletcher"], &["flexibility"], &["flexible"], ], - range: 5..=8, + range: 1..=8, }; static WORD_FEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57232,12 +105985,40 @@ static WORD_FEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["fielding"], &["feasible"], &["fetishes"]], - range: 5..=5, + 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 { @@ -57247,6 +106028,7 @@ static WORD_FED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -57255,6 +106037,7 @@ pub static WORD_FED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("really"), ], values: &[ + &["fidelity"], &["federation"], &["federation"], &["fidelity"], @@ -57274,9 +106057,10 @@ pub static WORD_FEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("thed"), dictgen::InsensitiveStr::Ascii("thes"), + dictgen::InsensitiveStr::Ascii("thing"), ], - values: &[&["fetched"], &["fetches"]], - range: 4..=4, + values: &[&["fetched"], &["fetches"], &["fetching"]], + range: 4..=5, }; static WORD_FEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57286,12 +106070,19 @@ static WORD_FEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ewary"), dictgen::InsensitiveStr::Ascii("raury"), dictgen::InsensitiveStr::Ascii("ruray"), dictgen::InsensitiveStr::Ascii("uary"), dictgen::InsensitiveStr::Ascii("urary"), ], - values: &[&["february"], &["february"], &["february"], &["february"]], + values: &[ + &["february"], + &["february"], + &["february"], + &["february"], + &["february"], + ], range: 4..=5, }; @@ -57302,11 +106093,71 @@ static WORD_FEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("uture"), + dictgen::InsensitiveStr::Ascii("utures"), ], - values: &[&["feasible"], &["feasible"]], - range: 5..=5, + 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"], + &["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 { @@ -57318,8 +106169,8 @@ static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_FAB_NODE), Some(&WORD_FAC_NODE), - None, - None, + Some(&WORD_FAD_NODE), + Some(&WORD_FAE_NODE), None, Some(&WORD_FAG_NODE), Some(&WORD_FAH_NODE), @@ -57339,10 +106190,21 @@ static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_FAV_NODE), None, 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, @@ -57362,6 +106224,7 @@ pub static WORD_FAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ourtie"), dictgen::InsensitiveStr::Ascii("ourties"), dictgen::InsensitiveStr::Ascii("outrable"), + dictgen::InsensitiveStr::Ascii("uourites"), ], values: &[ &["favorites"], @@ -57376,6 +106239,7 @@ pub static WORD_FAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["favourite"], &["favourites"], &["favourable"], + &["favourites"], ], range: 5..=8, }; @@ -57386,9 +106250,27 @@ static WORD_FAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_FAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ght")], - values: &[&["fought"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("ght"), + dictgen::InsensitiveStr::Ascii("ilure"), + dictgen::InsensitiveStr::Ascii("ilures"), + dictgen::InsensitiveStr::Ascii("nd"), + dictgen::InsensitiveStr::Ascii("ture"), + dictgen::InsensitiveStr::Ascii("tured"), + dictgen::InsensitiveStr::Ascii("tures"), + dictgen::InsensitiveStr::Ascii("turing"), + ], + values: &[ + &["fought"], + &["failure"], + &["failures"], + &["found", "fund"], + &["feature"], + &["featured"], + &["features"], + &["featuring"], + ], + range: 2..=6, }; static WORD_FAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57401,15 +106283,23 @@ pub static WORD_FAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, }; @@ -57421,6 +106311,7 @@ static WORD_FAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -57432,6 +106323,9 @@ pub static WORD_FAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("cistisk"), dictgen::InsensitiveStr::Ascii("cits"), dictgen::InsensitiveStr::Ascii("cization"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("es"), dictgen::InsensitiveStr::Ascii("hionalbe"), dictgen::InsensitiveStr::Ascii("hionalble"), dictgen::InsensitiveStr::Ascii("hiond"), @@ -57440,9 +106334,17 @@ pub static WORD_FAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("icsm"), dictgen::InsensitiveStr::Ascii("icst"), dictgen::InsensitiveStr::Ascii("icsts"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ion"), dictgen::InsensitiveStr::Ascii("lely"), + dictgen::InsensitiveStr::Ascii("sade"), + dictgen::InsensitiveStr::Ascii("sinate"), + dictgen::InsensitiveStr::Ascii("terner"), + dictgen::InsensitiveStr::Ascii("terners"), + dictgen::InsensitiveStr::Ascii("tr"), ], values: &[ + &["facade"], &["fascinated"], &["fascination"], &["fascinated"], @@ -57454,6 +106356,9 @@ pub static WORD_FAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fascists"], &["fascist"], &["fascination"], + &["faze", "phase"], + &["fazed", "phased"], + &["fazes", "phases"], &["fashionable"], &["fashionable"], &["fashioned"], @@ -57462,9 +106367,16 @@ pub static WORD_FAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fascism"], &["fascist"], &["fascists"], + &["fazing", "phasing"], + &["fashion"], &["falsely"], + &["facade"], + &["fascinate"], + &["fastener"], + &["fasteners"], + &["faster"], ], - range: 4..=9, + range: 1..=9, }; static WORD_FAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57475,17 +106387,27 @@ static WORD_FAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ies"), + dictgen::InsensitiveStr::Ascii("mework"), ], values: &[ &["fracking"], + &["fraction", "faction"], &["fahrenheit"], &["fahrenheit"], &["fahrenheit"], + &["fairest", "farthest"], + &["fahrenheit"], + &["fairies"], + &["framework"], ], - range: 5..=7, + range: 3..=8, }; static WORD_FAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57527,6 +106449,7 @@ pub static WORD_FAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("atsize"), dictgen::InsensitiveStr::Ascii("atsizing"), dictgen::InsensitiveStr::Ascii("atsy"), + dictgen::InsensitiveStr::Ascii("cyness"), dictgen::InsensitiveStr::Ascii("dation"), dictgen::InsensitiveStr::Ascii("faction"), dictgen::InsensitiveStr::Ascii("fcition"), @@ -57565,6 +106488,7 @@ pub static WORD_FAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["fantasize"], &["fantasizing"], &["fantasy"], + &["fanciness"], &["foundation"], &["fanfiction"], &["fanfiction"], @@ -57605,6 +106529,7 @@ pub static WORD_FAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -57615,7 +106540,12 @@ pub static WORD_FAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("oulsy"), dictgen::InsensitiveStr::Ascii("oust"), dictgen::InsensitiveStr::Ascii("ousy"), @@ -57624,6 +106554,7 @@ pub static WORD_FAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["familiar"], &["familiarity"], &["familiarize"], + &["familiar"], &["families"], &["familiar"], &["familiarize"], @@ -57634,7 +106565,12 @@ pub static WORD_FAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["familiarity"], &["familiarize"], &["familiarize"], + &["families"], + &["family"], &["familiar"], + &["family"], + &["families"], + &["family"], &["famously"], &["famous"], &["famously"], @@ -57651,18 +106587,31 @@ pub static WORD_FAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("lbck"), + dictgen::InsensitiveStr::Ascii("lhrough"), dictgen::InsensitiveStr::Ascii("licious"), + 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("t"), + dictgen::InsensitiveStr::Ascii("ure"), dictgen::InsensitiveStr::Ascii("vored"), dictgen::InsensitiveStr::Ascii("vors"), dictgen::InsensitiveStr::Ascii("vours"), @@ -57670,23 +106619,36 @@ pub static WORD_FAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["falcons"], &["falsely"], + &["flag"], + &["flags"], &["flagship"], + &["failed"], &["flaired"], + &["failure"], &["failures"], + &["fallback"], &["fallacious"], + &["fallback"], + &["fallthrough"], &["fallacious"], + &["fallthrough"], + &["fallthrough"], &["flamethrower"], &["falsely"], + &["flash", "false"], &["flashbacks"], &["flashed"], &["flashes"], &["flashing"], &["falsely"], + &["falsely"], + &["fault"], + &["failure"], &["flavored"], &["flavors"], &["flavours"], ], - range: 4..=9, + range: 1..=9, }; static WORD_FAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57696,11 +106658,74 @@ static WORD_FAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("lue"), + dictgen::InsensitiveStr::Ascii("luer"), + dictgen::InsensitiveStr::Ascii("lues"), dictgen::InsensitiveStr::Ascii("lurs"), dictgen::InsensitiveStr::Ascii("ncee"), + dictgen::InsensitiveStr::Ascii("reness"), + dictgen::InsensitiveStr::Ascii("roh"), + dictgen::InsensitiveStr::Ascii("way"), + dictgen::InsensitiveStr::Ascii("ways"), ], - values: &[&["failures"], &["fiancee"]], - range: 4..=4, + values: &[ + &["failed", "fade"], + &["failed"], + &["failed"], + &["failed"], + &["failed"], + &["failure"], + &["fails"], + &["facilities"], + &["facility"], + &["failed"], + &["failure"], + &["failures"], + &["failover"], + &["fail"], + &["failed"], + &["failure"], + &["failing"], + &["failure"], + &["failure"], + &["failsafe"], + &["failsafes"], + &["fail", "failed"], + &["failure"], + &["failure"], + &["failure"], + &["failures"], + &["failures"], + &["fiancee"], + &["fairness"], + &["pharaoh"], + &["fairway"], + &["fairways"], + ], + range: 2..=6, }; static WORD_FAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57732,6 +106757,31 @@ pub static WORD_FAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -57741,10 +106791,14 @@ pub static WORD_FAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ 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"), @@ -57753,21 +106807,37 @@ pub static WORD_FAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tuallity"), dictgen::InsensitiveStr::Ascii("tualy"), @@ -57776,10 +106846,14 @@ pub static WORD_FAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["facebook"], &["facebook"], + &["facedrawing"], + &["faces"], &["facepalm"], &["facepalm"], &["facilitate"], &["facilitated"], + &["facilitates"], + &["facilitating"], &["facilities"], &["facilitate"], &["facilitate"], @@ -57788,27 +106862,43 @@ pub static WORD_FAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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", "favour"], + &["favourite"], + &["favourites"], + &["favours"], &["fascinated"], &["fascination"], &["fascism"], &["fascist"], &["fascists"], + &["factorization"], &["factors"], - &["factors"], + &["factorization"], + &["factors", "factories"], &["factually"], &["factually"], &["factually"], ], - range: 3..=9, + range: 2..=10, }; static WORD_FAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57818,6 +106908,7 @@ static WORD_FAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_FAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ility"), dictgen::InsensitiveStr::Ascii("ircation"), dictgen::InsensitiveStr::Ascii("oulus"), dictgen::InsensitiveStr::Ascii("riacted"), @@ -57830,6 +106921,7 @@ pub static WORD_FAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ulos"), ], values: &[ + &["facility"], &["fabrication"], &["fabulous"], &["fabricated"], @@ -57872,12 +106964,23 @@ static WORD_E_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_ET_NODE), Some(&WORD_EU_NODE), Some(&WORD_EV_NODE), - None, + Some(&WORD_EW_NODE), Some(&WORD_EX_NODE), Some(&WORD_EY_NODE), - None, + 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, @@ -57898,12 +107001,13 @@ pub static WORD_EY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("eshdaow"), dictgen::InsensitiveStr::Ascii("gptian"), dictgen::InsensitiveStr::Ascii("gptians"), + dictgen::InsensitiveStr::Ascii("t"), dictgen::InsensitiveStr::Ascii("tmology"), ], values: &[ - &["year"], - &["years"], - &["years"], + &["year", "eyas"], + &["years", "eyas"], + &["years", "eyas"], &["eyeballs"], &["eyeballs"], &["eyeballs"], @@ -57914,9 +107018,10 @@ pub static WORD_EY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["eyeshadow"], &["egyptian"], &["egyptians"], + &["yet"], &["etymology"], ], - range: 2..=8, + range: 1..=8, }; static WORD_EX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -57938,14 +107043,14 @@ static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_EXL_NODE), Some(&WORD_EXM_NODE), - None, + 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), - None, + Some(&WORD_EXU_NODE), None, None, None, @@ -57953,6 +107058,17 @@ static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> 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")], + values: &[&["exuberant"]], + range: 6..=6, +}; + static WORD_EXT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_EXT_CHILDREN), value: None, @@ -57972,14 +107088,14 @@ static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, - None, + Some(&WORD_EXTN_NODE), Some(&WORD_EXTO_NODE), None, None, Some(&WORD_EXTR_NODE), None, None, - None, + Some(&WORD_EXTU_NODE), None, None, None, @@ -57987,6 +107103,29 @@ static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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, @@ -58017,10 +107156,21 @@ static WORD_EXTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, 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, @@ -58041,6 +107191,7 @@ pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -58049,6 +107200,7 @@ pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di values: &[ &["extraordinarily"], &["extraordinary"], + &["extraordinary"], &["extrapolate"], &["extraordinarily"], &["extraordinary"], @@ -58063,9 +107215,19 @@ static WORD_EXTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_EXTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("mists")], - values: &[&["extremists"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("me"), + dictgen::InsensitiveStr::Ascii("mely"), + dictgen::InsensitiveStr::Ascii("mists"), + dictgen::InsensitiveStr::Ascii("mly"), + ], + values: &[ + &["extreme"], + &["extremely"], + &["extremists"], + &["extremely"], + ], + range: 2..=5, }; static WORD_EXTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58075,12 +107237,21 @@ static WORD_EXTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -58092,18 +107263,30 @@ pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -58115,12 +107298,15 @@ pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["extremes"], &["extremists"], &["extremists"], + &["extremities"], &["extremely"], &["extremely"], - &["extremes"], + &["extremes", "extrema"], + &["external"], + &["externally"], &["externally"], ], - range: 2..=8, + range: 1..=8, }; static WORD_EXTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58130,14 +107316,22 @@ static WORD_EXTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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"), @@ -58159,26 +107353,49 @@ pub static WORD_EXTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], &["extraction"], + &["extracting"], + &["extractions"], &["extraction"], &["extraction"], &["extraction"], &["extradition"], &["extraction"], + &["extraneous"], &["extravagant"], + &["extraneous"], &["extraordinarily"], &["extraordinary"], &["extraordinary"], @@ -58203,15 +107420,30 @@ pub static WORD_EXTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["extrapolate"], &["extrapolate"], &["extrapolate"], + &["extrapolate"], + &["extract"], + &["extracted"], &["extraterrestrial"], &["extraterrestrials"], + &["extracts"], + &["exctracting"], + &["extraction"], + &["extractor"], + &["extractors"], + &["extracts"], &["extravagant"], &["extravagant"], &["extravagant"], + &["extroversion"], &["extravagant"], &["extravagant"], + &["extract"], + &["extracted"], + &["extracting"], + &["extractors"], + &["extracts"], ], - range: 3..=11, + range: 1..=11, }; static WORD_EXTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58228,15 +107460,40 @@ pub static WORD_EXTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("nt")], - values: &[&["extinct"]], - range: 2..=2, + keys: &[ + 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: &[ + &["extinct", "extant"], + &["exist"], + &["exit"], + &["excited", "exited"], + &["exciting", "exiting"], + &["exits", "excites"], + ], + range: 1..=4, }; static WORD_EXTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58246,19 +107503,45 @@ static WORD_EXTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_EXTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("dn"), + dictgen::InsensitiveStr::Ascii("dned"), + dictgen::InsensitiveStr::Ascii("dner"), + dictgen::InsensitiveStr::Ascii("dners"), + dictgen::InsensitiveStr::Ascii("dns"), dictgen::InsensitiveStr::Ascii("mely"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("nal"), + dictgen::InsensitiveStr::Ascii("ndded"), dictgen::InsensitiveStr::Ascii("ndes"), + dictgen::InsensitiveStr::Ascii("ndet"), dictgen::InsensitiveStr::Ascii("ndos"), + dictgen::InsensitiveStr::Ascii("ndsions"), + dictgen::InsensitiveStr::Ascii("ned"), + dictgen::InsensitiveStr::Ascii("neded"), dictgen::InsensitiveStr::Ascii("nion"), + dictgen::InsensitiveStr::Ascii("nions"), + dictgen::InsensitiveStr::Ascii("nisble"), + dictgen::InsensitiveStr::Ascii("nsability"), + dictgen::InsensitiveStr::Ascii("nsiable"), dictgen::InsensitiveStr::Ascii("nsie"), + dictgen::InsensitiveStr::Ascii("nsilbe"), dictgen::InsensitiveStr::Ascii("nsiones"), dictgen::InsensitiveStr::Ascii("nsis"), dictgen::InsensitiveStr::Ascii("nsivelly"), dictgen::InsensitiveStr::Ascii("nsivley"), dictgen::InsensitiveStr::Ascii("nsivly"), + dictgen::InsensitiveStr::Ascii("nson"), + dictgen::InsensitiveStr::Ascii("nstion"), + dictgen::InsensitiveStr::Ascii("nstions"), + dictgen::InsensitiveStr::Ascii("nted"), dictgen::InsensitiveStr::Ascii("ntion"), dictgen::InsensitiveStr::Ascii("ntions"), + dictgen::InsensitiveStr::Ascii("pect"), + dictgen::InsensitiveStr::Ascii("pecting"), + dictgen::InsensitiveStr::Ascii("pects"), + dictgen::InsensitiveStr::Ascii("ral"), dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("reme"), dictgen::InsensitiveStr::Ascii("rioara"), dictgen::InsensitiveStr::Ascii("rioare"), dictgen::InsensitiveStr::Ascii("riour"), @@ -58268,22 +107551,56 @@ pub static WORD_EXTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("rmism"), dictgen::InsensitiveStr::Ascii("rmist"), dictgen::InsensitiveStr::Ascii("rmists"), + dictgen::InsensitiveStr::Ascii("rmporaneous"), dictgen::InsensitiveStr::Ascii("rnaly"), + dictgen::InsensitiveStr::Ascii("rnel"), + dictgen::InsensitiveStr::Ascii("rnelly"), + dictgen::InsensitiveStr::Ascii("rnels"), + dictgen::InsensitiveStr::Ascii("sion"), + dictgen::InsensitiveStr::Ascii("sions"), + dictgen::InsensitiveStr::Ascii("snion"), + dictgen::InsensitiveStr::Ascii("snions"), ], values: &[ + &["extend"], + &["extended"], + &["extender"], + &["extenders"], + &["extends"], &["extremely"], + &["extent"], + &["external"], + &["extended"], &["extends"], + &["extended"], &["extends"], + &["extensions"], + &["extended"], + &["extended"], &["extension"], + &["extension", "extensions"], + &["extensible"], + &["extensibility"], + &["extensible"], &["extensive"], + &["extensible"], &["extensions"], &["extensions"], &["extensively"], &["extensively"], &["extensively"], &["extension"], + &["extension"], &["extensions"], + &["extended"], + &["extension"], + &["extensions"], + &["expect"], + &["expecting"], + &["expects"], + &["external"], &["exerted"], + &["extreme"], &["exterior"], &["exterior"], &["exterior"], @@ -58293,9 +107610,17 @@ pub static WORD_EXTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["extremism"], &["extremist"], &["extremists"], + &["extemporaneous"], &["externally"], + &["external"], + &["externally"], + &["externals"], + &["extension"], + &["extensions"], + &["extension"], + &["extensions"], ], - range: 3..=8, + range: 1..=11, }; static WORD_EXTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58304,9 +107629,25 @@ static WORD_EXTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_EXTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ctly")], - values: &[&["exactly"]], - range: 4..=4, + 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"], + &["extraction"], + &["exactly"], + &["ecstasy"], + &["external"], + &["externally"], + &["ecstatic"], + ], + range: 2..=6, }; static WORD_EXS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58316,13 +107657,52 @@ static WORD_EXS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("tream"), ], - values: &[&["existence"], &["existed"], &["existent"], &["existing"]], - range: 4..=6, + values: &[ + &["exists", "exist"], + &["existence"], + &["existent"], + &["existing"], + &["exists"], + &["exist", "exit"], + &["existence"], + &["existed"], + &["existent"], + &["existing"], + &["exists", "exist"], + &["expect"], + &["expected"], + &["expectedly"], + &["expecting"], + &["expects"], + &["expense"], + &["expensed"], + &["expenses"], + &["ecstasy"], + &["extreme"], + ], + range: 2..=8, }; static WORD_EXR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58331,9 +107711,14 @@ static WORD_EXR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_EXR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("essed")], - values: &[&["expressed"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("a"), + dictgen::InsensitiveStr::Ascii("act"), + dictgen::InsensitiveStr::Ascii("essed"), + dictgen::InsensitiveStr::Ascii("ession"), + ], + values: &[&["extra"], &["extract"], &["expressed"], &["expression"]], + range: 1..=6, }; static WORD_EXP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58344,7 +107729,7 @@ static WORD_EXP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_EXPA_NODE), None, - None, + Some(&WORD_EXPC_NODE), None, Some(&WORD_EXPE_NODE), None, @@ -58357,11 +107742,11 @@ static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_EXPO_NODE), - None, + Some(&WORD_EXPP_NODE), None, Some(&WORD_EXPR_NODE), None, - None, + Some(&WORD_EXPT_NODE), None, None, None, @@ -58370,6 +107755,17 @@ static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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, @@ -58378,51 +107774,85 @@ static WORD_EXPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_EXPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ensive"), + 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("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("opiated"), dictgen::InsensitiveStr::Ascii("opiation"), + dictgen::InsensitiveStr::Ascii("ted"), ], values: &[ &["expressive"], &["expression"], + &["expression", "expressions"], &["expressions"], + &["expressible"], &["expression"], &["expressive"], &["expresses"], &["expressive"], &["expressive"], &["expression"], + &["expression"], &["expressions"], &["expressly"], - &["expresses"], + &["espresso"], + &["expresses", "express"], + &["expression"], + &["expressions"], &["expressive"], &["expressive"], &["expressly"], &["expiration"], + &["experience"], + &["experienced"], + &["experiences"], &["expires"], &["experimental"], &["expropriated"], &["expropriation"], + &["exported"], ], range: 3..=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, @@ -58434,6 +107864,15 @@ pub static WORD_EXPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("dential"), dictgen::InsensitiveStr::Ascii("dentially"), dictgen::InsensitiveStr::Ascii("dition"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("ential"), + dictgen::InsensitiveStr::Ascii("entially"), + 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"), @@ -58447,16 +107886,25 @@ pub static WORD_EXPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("rtas"), dictgen::InsensitiveStr::Ascii("rtes"), + dictgen::InsensitiveStr::Ascii("rtet"), dictgen::InsensitiveStr::Ascii("rtfs"), dictgen::InsensitiveStr::Ascii("sees"), dictgen::InsensitiveStr::Ascii("sicion"), @@ -58470,6 +107918,15 @@ pub static WORD_EXPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["exponential"], &["exponentially"], &["exposition"], + &["exposed"], + &["exponential"], + &["exponentially"], + &["export", "expert"], + &["exported"], + &["exploit"], + &["exploitation"], + &["exploited"], + &["exploits"], &["explode"], &["explodes"], &["exploding"], @@ -58483,16 +107940,25 @@ pub static WORD_EXPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["explosions"], &["explosive"], &["explosives"], + &["exponent"], + &["exponentiation"], + &["exponential"], + &["exponentially"], + &["exponentially"], + &["exponents"], &["exponential"], &["exponentially"], &["exponential"], - &["exponentially"], - &["exponential"], + &["exponentiation"], &["exponentially"], &["exponential"], &["exponential"], + &["exponential"], + &["exponential"], + &["expression"], &["exports"], &["exports"], + &["exported", "exporter"], &["exports"], &["exposes"], &["exposition"], @@ -58512,7 +107978,7 @@ static WORD_EXPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_EXPL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_EXPLA_NODE), None, - None, + Some(&WORD_EXPLC_NODE), None, Some(&WORD_EXPLE_NODE), None, @@ -58567,6 +108033,7 @@ pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -58584,11 +108051,14 @@ pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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: &[ @@ -58602,7 +108072,8 @@ pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["exploitative"], &["exploitation"], &["exploits"], - &["exploiting"], + &["exploiting", "explosion", "exploitation", "exploit"], + &["explosions", "exploitations", "exploits"], &["exploitative"], &["exploration"], &["exploration"], @@ -58620,14 +108091,17 @@ pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["explosions"], &["explosives"], &["explosives"], + &["exploit", "explore"], &["exploration"], + &["exploitation", "exploration"], &["explode"], &["exploitation"], &["exploitative"], &["exploited"], + &["exploiting", "exploring"], &["explosions"], ], - range: 2..=7, + range: 1..=7, }; static WORD_EXPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58637,18 +108111,26 @@ static WORD_EXPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cat"), dictgen::InsensitiveStr::Ascii("catia"), dictgen::InsensitiveStr::Ascii("catie"), dictgen::InsensitiveStr::Ascii("catif"), dictgen::InsensitiveStr::Ascii("catii"), 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("city"), dictgen::InsensitiveStr::Ascii("ct"), + dictgen::InsensitiveStr::Ascii("ctely"), + dictgen::InsensitiveStr::Ascii("ctily"), dictgen::InsensitiveStr::Ascii("ctly"), + dictgen::InsensitiveStr::Ascii("cty"), dictgen::InsensitiveStr::Ascii("nation"), dictgen::InsensitiveStr::Ascii("natory"), dictgen::InsensitiveStr::Ascii("ot"), @@ -58656,20 +108138,33 @@ pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("oted"), dictgen::InsensitiveStr::Ascii("oting"), dictgen::InsensitiveStr::Ascii("ots"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("tit"), + dictgen::InsensitiveStr::Ascii("tly"), + dictgen::InsensitiveStr::Ascii("zit"), + dictgen::InsensitiveStr::Ascii("zitly"), ], values: &[ + &["explicate"], &["explicit"], &["explicit"], &["explicit"], &["explicit"], &["explicitly"], &["explicit"], + &["explicit"], + &["explicitly"], + &["explicit", "explicitly"], + &["explicit", "explicitly"], &["explicitly"], &["explicitly"], &["explicitly"], &["explicitly"], &["explicit"], &["explicitly"], + &["explicitly"], + &["explicitly"], + &["explicitly", "explicit"], &["explanation"], &["explanatory"], &["exploit"], @@ -58677,8 +108172,13 @@ pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["exploited"], &["exploiting"], &["exploits"], + &["explicit"], + &["explicit"], + &["explicitly"], + &["explicit"], + &["explicitly"], ], - range: 2..=7, + range: 1..=7, }; static WORD_EXPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58688,12 +108188,35 @@ static WORD_EXPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["explanation"], &["explanations"], &["explanatory"]], - range: 6..=7, + 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")], + values: &[&["explicit"]], + range: 2..=2, }; static WORD_EXPLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58704,6 +108227,8 @@ static WORD_EXPLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -58717,9 +108242,13 @@ pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -58733,8 +108262,10 @@ pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["explaining"], &["explanatory"], &["explanatory"], + &["explanation"], + &["explanations"], ], - range: 3..=7, + range: 3..=8, }; static WORD_EXPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -58744,40 +108275,60 @@ static WORD_EXPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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("rience"), + dictgen::InsensitiveStr::Ascii("riences"), + dictgen::InsensitiveStr::Ascii("rimental"), ], values: &[ + &["explicit"], + &["explicitly"], &["expenditures"], &["expedition"], + &["expedition"], &["expeditions"], &["experience"], &["experienced"], &["experiences"], &["experiencing"], + &["experience"], + &["experiences"], &["expires"], + &["explicitly"], &["expiration"], &["expires"], + &["expiretime"], &["experiment"], &["experimental"], &["experimentation"], &["experimented"], &["experimenting"], &["experiments"], + &["experience"], + &["experiences"], + &["experimental"], ], range: 3..=11, }; @@ -58792,7 +108343,7 @@ static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_EXPEC_NODE), Some(&WORD_EXPED_NODE), - None, + Some(&WORD_EXPEE_NODE), None, None, None, @@ -58803,14 +108354,14 @@ static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_EXPEM_NODE), Some(&WORD_EXPEN_NODE), None, - None, + Some(&WORD_EXPEP_NODE), None, Some(&WORD_EXPER_NODE), + Some(&WORD_EXPES_NODE), + Some(&WORD_EXPET_NODE), None, None, - None, - None, - None, + Some(&WORD_EXPEW_NODE), Some(&WORD_EXPEX_NODE), None, None, @@ -58822,120 +108373,1539 @@ static WORD_EXPEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_EXPEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tancy")], - values: &[&["expectancy"]], - range: 5..=5, + 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_EXPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_EXPER_CHILDREN), +static WORD_EXPEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_EXPEW_CHILDREN), value: None, }; -pub static WORD_EXPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_EXPEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("amental"), - dictgen::InsensitiveStr::Ascii("eince"), - dictgen::InsensitiveStr::Ascii("einced"), - dictgen::InsensitiveStr::Ascii("einces"), - dictgen::InsensitiveStr::Ascii("eincing"), - dictgen::InsensitiveStr::Ascii("ement"), - dictgen::InsensitiveStr::Ascii("emental"), - dictgen::InsensitiveStr::Ascii("ementation"), - dictgen::InsensitiveStr::Ascii("ementing"), - dictgen::InsensitiveStr::Ascii("ements"), - dictgen::InsensitiveStr::Ascii("iance"), - dictgen::InsensitiveStr::Ascii("ianced"), - dictgen::InsensitiveStr::Ascii("iances"), - dictgen::InsensitiveStr::Ascii("iancing"), - dictgen::InsensitiveStr::Ascii("ieced"), - dictgen::InsensitiveStr::Ascii("ieces"), - dictgen::InsensitiveStr::Ascii("iemnt"), - dictgen::InsensitiveStr::Ascii("iemntal"), - dictgen::InsensitiveStr::Ascii("iemnted"), - dictgen::InsensitiveStr::Ascii("iemnts"), - dictgen::InsensitiveStr::Ascii("ienceing"), - dictgen::InsensitiveStr::Ascii("iened"), - dictgen::InsensitiveStr::Ascii("iening"), - dictgen::InsensitiveStr::Ascii("iense"), - dictgen::InsensitiveStr::Ascii("imantal"), - dictgen::InsensitiveStr::Ascii("imantation"), - dictgen::InsensitiveStr::Ascii("imentacion"), - dictgen::InsensitiveStr::Ascii("imentaion"), - dictgen::InsensitiveStr::Ascii("imentais"), - dictgen::InsensitiveStr::Ascii("imentan"), - dictgen::InsensitiveStr::Ascii("imentating"), - dictgen::InsensitiveStr::Ascii("imentella"), - dictgen::InsensitiveStr::Ascii("imenterade"), - dictgen::InsensitiveStr::Ascii("imentes"), - dictgen::InsensitiveStr::Ascii("imention"), - dictgen::InsensitiveStr::Ascii("imentle"), - dictgen::InsensitiveStr::Ascii("imentors"), - dictgen::InsensitiveStr::Ascii("imentos"), - dictgen::InsensitiveStr::Ascii("imentul"), - dictgen::InsensitiveStr::Ascii("imet"), - dictgen::InsensitiveStr::Ascii("imetal"), - dictgen::InsensitiveStr::Ascii("imeted"), - dictgen::InsensitiveStr::Ascii("imintation"), - dictgen::InsensitiveStr::Ascii("mient"), - dictgen::InsensitiveStr::Ascii("ssion"), - dictgen::InsensitiveStr::Ascii("ssions"), - dictgen::InsensitiveStr::Ascii("tas"), - dictgen::InsensitiveStr::Ascii("tis"), - dictgen::InsensitiveStr::Ascii("tos"), + 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: &[ - &["experimental"], - &["experience"], - &["experienced"], - &["experiences"], - &["experiencing"], &["experiment"], &["experimental"], + &["experimentally"], &["experimentation"], + &["experimentations"], + &["experimented"], + &["experimental"], + &["experimentally"], + &["experimenter"], + &["experimenters"], &["experimenting"], &["experiments"], - &["experience"], - &["experienced"], - &["experiences"], - &["experiencing"], - &["experienced"], - &["experiences"], + ], + 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("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"], - &["experiments"], - &["experiencing"], - &["experienced"], - &["experiencing"], - &["experiences"], &["experimental"], - &["experimentation"], - &["experimentation"], - &["experimentation"], - &["experiments"], - &["experimentation"], - &["experimentation"], - &["experimental"], - &["experimented"], - &["experiments"], + &["experimentally"], + &["experimenter"], + &["experimenters"], &["experimenting"], - &["experimented"], - &["experiments"], - &["experiments"], - &["experimental"], - &["experiments"], - &["experimental"], - &["experimented"], - &["experimentation"], &["experiments"], + &["expecting"], + &["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"], - &["experts"], - &["experts"], - &["experts"], + &["expect"], + &["expected"], + &["expectedly"], + &["expecting"], ], - range: 3..=10, + 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 { @@ -58984,11 +109954,54 @@ static WORD_EXPEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["exemption"], &["exemptions"]], - range: 4..=5, + 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 { @@ -59011,9 +110024,96 @@ static WORD_EXPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_EXPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ments")], - values: &[&["experiments"]], - range: 5..=5, + 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 { @@ -59047,12 +110147,18 @@ static WORD_EXPEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -59062,13 +110168,19 @@ pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("tus"), ], values: &[ + &["expected"], &["expected"], &["especially"], &["expectation"], + &["expectations"], &["expectancy"], &["expectancy"], &["expectancy"], &["expectation"], + &["expectations"], + &["expectations"], + &["expected"], + &["expected"], &["expectancy"], &["expects"], &["exception"], @@ -59080,6 +110192,29 @@ pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("t"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("tedly"), + dictgen::InsensitiveStr::Ascii("ting"), + ], + values: &[ + &["exception"], + &["expect"], + &["expected"], + &["expectedly"], + &["expecting"], + ], + range: 1..=6, +}; + static WORD_EXPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_EXPA_CHILDREN), value: None, @@ -59091,15 +110226,24 @@ pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("lined"), dictgen::InsensitiveStr::Ascii("lining"), dictgen::InsensitiveStr::Ascii("lins"), + dictgen::InsensitiveStr::Ascii("nation"), + dictgen::InsensitiveStr::Ascii("nations"), dictgen::InsensitiveStr::Ascii("ndas"), dictgen::InsensitiveStr::Ascii("ndes"), + 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: &[ @@ -59107,15 +110251,24 @@ pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["explained"], &["explaining"], &["explains"], + &["explanation", "expansion"], + &["explanations", "expansions"], &["expands"], &["expands"], + &["expanding"], + &["expansion"], + &["expansions"], &["expansions"], &["expansive"], + &["expansion"], + &["expansions"], &["expansive"], &["expansions"], &["expansions"], + &["expansions", "expansion"], &["expansions"], - &["expansions"], + &["expiration"], + &["expansion"], &["expatriate"], ], range: 3..=7, @@ -59129,29 +110282,48 @@ static WORD_EXO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], + &["exported", "extorted", "exerted"], &["exoskeleton"], &["exotics"], &["exotics"], ], - range: 4..=8, + 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("try")], + values: &[&["entry"]], + range: 3..=3, }; static WORD_EXM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59160,9 +110332,25 @@ static WORD_EXM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_EXM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("aple")], - values: &[&["example"]], - range: 4..=4, + 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 { @@ -59172,6 +110360,7 @@ static WORD_EXL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -59183,14 +110372,30 @@ pub static WORD_EXL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -59202,14 +110407,29 @@ pub static WORD_EXL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["exclusively"], &["exclusives"], &["exclusivity"], + &["explicit"], + &["explicit"], + &["explicitly"], + &["explicitly"], &["exiled"], &["exploding"], + &["exploit"], + &["exploited"], + &["exploits"], &["explorer"], &["explorers"], &["explosion"], - &["excludes"], + &["exclude", "exude"], + &["excluded", "exuded"], + &["excludes", "exudes"], + &["excluding", "exuding"], + &["exclusion"], + &["exclusionary"], + &["exclusions"], + &["exclusive"], + &["exclusively"], ], - range: 4..=8, + range: 3..=8, }; static WORD_EXI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59225,16 +110445,27 @@ pub static WORD_EXI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("cting"), 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"), @@ -59243,6 +110474,16 @@ pub static WORD_EXI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("stet"), dictgen::InsensitiveStr::Ascii("stince"), dictgen::InsensitiveStr::Ascii("stnace"), + dictgen::InsensitiveStr::Ascii("stng"), + dictgen::InsensitiveStr::Ascii("stsing"), + dictgen::InsensitiveStr::Ascii("stung"), + dictgen::InsensitiveStr::Ascii("sty"), + dictgen::InsensitiveStr::Ascii("stying"), + dictgen::InsensitiveStr::Ascii("tation"), + dictgen::InsensitiveStr::Ascii("tations"), + dictgen::InsensitiveStr::Ascii("te"), + dictgen::InsensitiveStr::Ascii("xst"), + dictgen::InsensitiveStr::Ascii("xt"), ], values: &[ &["exhibition"], @@ -59251,16 +110492,27 @@ pub static WORD_EXI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["exciting"], &["extinct"], &["expiration"], + &["expire"], + &["expired"], + &["expires"], + &["existing"], + &["exist"], + &["existed"], + &["existent"], &["existing"], &["existing"], + &["exists"], &["existence"], &["existence"], &["existent"], &["existent"], &["existential"], + &["exitstatus"], + &["existence"], &["existential"], &["existed"], &["existential"], + &["existence"], &["existential"], &["existential"], &["existential"], @@ -59269,8 +110521,18 @@ pub static WORD_EXI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["existent"], &["existence"], &["existence"], + &["existing"], + &["existing"], + &["existing"], + &["exist"], + &["existing"], + &["excitation"], + &["excitations"], + &["exit", "excite", "exits"], + &["exist"], + &["exist"], ], - range: 3..=10, + range: 2..=10, }; static WORD_EXH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59281,45 +110543,75 @@ static WORD_EXH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("ist"), + dictgen::InsensitiveStr::Ascii("istance"), + dictgen::InsensitiveStr::Ascii("isted"), + dictgen::InsensitiveStr::Ascii("istence"), + dictgen::InsensitiveStr::Ascii("isting"), + dictgen::InsensitiveStr::Ascii("ists"), 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"], + &["exhausted"], &["exhaustion"], &["exhaustion"], &["exhaustion"], &["exhaustion"], + &["exhaustivity"], + &["exhaust"], + &["exhausted"], &["exhibition"], &["exhibits"], &["exhibition"], &["exhibits"], &["exhibition"], + &["exist"], + &["existence"], + &["existed"], + &["existence"], + &["existing"], + &["exists"], &["exhaust"], &["exhausted"], &["exhausting"], &["exhaustion"], + &["exhaustiveness"], ], - range: 4..=7, + range: 3..=10, }; static WORD_EXE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59341,21 +110633,32 @@ static WORD_EXE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_EXEL_NODE), Some(&WORD_EXEM_NODE), - None, + Some(&WORD_EXEN_NODE), None, Some(&WORD_EXEP_NODE), - None, + Some(&WORD_EXEQ_NODE), Some(&WORD_EXER_NODE), None, None, Some(&WORD_EXEU_NODE), None, 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, @@ -59363,11 +110666,22 @@ static WORD_EXEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ctioner"), dictgen::InsensitiveStr::Ascii("ctions"), + dictgen::InsensitiveStr::Ascii("tion"), ], - values: &[&["executioner"], &["executions"]], - range: 6..=7, + values: &[ + &["execute"], + &["executed"], + &["executes"], + &["executioner"], + &["executions"], + &["execution"], + ], + range: 3..=7, }; static WORD_EXER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59384,7 +110698,11 @@ pub static WORD_EXER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("cizes"), dictgen::InsensitiveStr::Ascii("cizing"), dictgen::InsensitiveStr::Ascii("pt"), @@ -59394,6 +110712,7 @@ pub static WORD_EXER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("sicing"), dictgen::InsensitiveStr::Ascii("sising"), dictgen::InsensitiveStr::Ascii("size"), + dictgen::InsensitiveStr::Ascii("sizes"), dictgen::InsensitiveStr::Ascii("sizing"), dictgen::InsensitiveStr::Ascii("ternal"), ], @@ -59404,8 +110723,12 @@ pub static WORD_EXER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["exercising"], &["exercised"], &["exercise"], + &["exercises", "exercise"], + &["exercised"], &["exercises"], &["exercising"], + &["exercising"], + &["exercise"], &["exercise"], &["exercising"], &["excerpt"], @@ -59415,12 +110738,24 @@ pub static WORD_EXER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["exercising"], &["exercising"], &["exercise"], + &["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, @@ -59428,16 +110763,61 @@ static WORD_EXEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_EXEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"], + &["expectation"], + &["expectations"], + &["expected"], + &["expectedly"], + &["expecting"], + &["expects"], &["exemption"], &["exemptions"], - &["except"], + &["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, }; @@ -59448,9 +110828,14 @@ static WORD_EXEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_EXEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ple")], - values: &[&["example"]], - range: 3..=3, + 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 { @@ -59487,61 +110872,509 @@ static WORD_EXEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_EXEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("dingly")], - values: &[&["exceedingly"]], - range: 6..=6, + 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::Flat(&WORD_EXEC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_EXEC_CHILDREN), value: None, }; -pub static WORD_EXEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ising"), - dictgen::InsensitiveStr::Ascii("itioner"), - dictgen::InsensitiveStr::Ascii("ption"), - dictgen::InsensitiveStr::Ascii("ptional"), - dictgen::InsensitiveStr::Ascii("ptions"), + 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("re"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("res"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("ting"), dictgen::InsensitiveStr::Ascii("tion"), - dictgen::InsensitiveStr::Ascii("tuable"), - dictgen::InsensitiveStr::Ascii("tuables"), - dictgen::InsensitiveStr::Ascii("tued"), - dictgen::InsensitiveStr::Ascii("tuing"), - dictgen::InsensitiveStr::Ascii("tuion"), - dictgen::InsensitiveStr::Ascii("tuioner"), - dictgen::InsensitiveStr::Ascii("tuioners"), - dictgen::InsensitiveStr::Ascii("tuions"), - dictgen::InsensitiveStr::Ascii("tuive"), - dictgen::InsensitiveStr::Ascii("tuives"), - dictgen::InsensitiveStr::Ascii("usions"), - dictgen::InsensitiveStr::Ascii("utabe"), - dictgen::InsensitiveStr::Ascii("utabil"), - dictgen::InsensitiveStr::Ascii("utible"), - dictgen::InsensitiveStr::Ascii("utie"), - dictgen::InsensitiveStr::Ascii("utin"), - dictgen::InsensitiveStr::Ascii("utiner"), - dictgen::InsensitiveStr::Ascii("utings"), - dictgen::InsensitiveStr::Ascii("utionar"), - dictgen::InsensitiveStr::Ascii("utioneer"), - dictgen::InsensitiveStr::Ascii("utioneers"), - dictgen::InsensitiveStr::Ascii("utionees"), - dictgen::InsensitiveStr::Ascii("utioness"), - dictgen::InsensitiveStr::Ascii("utionier"), - dictgen::InsensitiveStr::Ascii("utionner"), - dictgen::InsensitiveStr::Ascii("utionor"), - dictgen::InsensitiveStr::Ascii("utivas"), + 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: &[ - &["exercising"], - &["executioner"], - &["exception"], - &["exceptional"], - &["exceptions"], + &["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"], + &["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"), + ], + values: &[&["execute"], &["executed"], &["executes"]], + range: 1..=2, +}; + +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("ution"), + dictgen::InsensitiveStr::Ascii("utions"), + ], + values: &[ + &["executable"], + &["executed", "expected"], + &["executing", "expecting"], + &["execution"], + &["executions"], + &["executable"], + &["executableness"], + &["executable", "executables"], &["executed"], &["executing"], &["execution"], @@ -59550,25 +111383,62 @@ pub static WORD_EXEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["executions"], &["executive"], &["executives"], - &["executions"], - &["executable"], - &["executable"], - &["executable"], - &["executive"], &["execution"], - &["executioner"], &["executions"], - &["executioner"], - &["executioner"], - &["executioner"], - &["executions"], - &["executions"], - &["executioner"], - &["executioner"], - &["executioner"], - &["executives"], ], - range: 4..=9, + 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("sing"), + dictgen::InsensitiveStr::Ascii("tioner"), + ], + values: &[&["exercising"], &["executioner"]], + range: 4..=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("ed"), + dictgen::InsensitiveStr::Ascii("eded"), + dictgen::InsensitiveStr::Ascii("eds"), + dictgen::InsensitiveStr::Ascii("ption"), + dictgen::InsensitiveStr::Ascii("ptions"), + ], + values: &[ + &["exceed"], + &["exceeded"], + &["exceeds"], + &["exception"], + &["exceptions"], + ], + range: 2..=6, }; static WORD_EXC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59579,7 +111449,7 @@ static WORD_EXC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_EXCA_NODE), None, - None, + Some(&WORD_EXCC_NODE), None, Some(&WORD_EXCE_NODE), None, @@ -59596,7 +111466,7 @@ static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_EXCR_NODE), None, - None, + Some(&WORD_EXCT_NODE), Some(&WORD_EXCU_NODE), None, None, @@ -59623,6 +111493,13 @@ pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -59636,8 +111513,30 @@ pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["exclusivity"], &["exclusively"], &["excruciating"], + &["executable"], + &["executables"], + &["execute"], + &["executed"], + &["executes"], + &["executing"], + &["execution"], ], - range: 3..=8, + 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"), + ], + values: &[&["extracted"], &["extract"], &["extracted"]], + range: 4..=6, }; static WORD_EXCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59647,10 +111546,11 @@ static WORD_EXCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["excerpt"], &["excruciating"]], + values: &[&["extract"], &["excerpt"], &["excruciating"]], range: 3..=8, }; @@ -59661,18 +111561,38 @@ static WORD_EXCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: 5..=9, + range: 2..=9, }; static WORD_EXCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59694,6 +111614,7 @@ static WORD_EXCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -59701,9 +111622,12 @@ pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("use"), dictgen::InsensitiveStr::Ascii("usie"), + dictgen::InsensitiveStr::Ascii("usiv"), dictgen::InsensitiveStr::Ascii("usivas"), dictgen::InsensitiveStr::Ascii("usiveity"), dictgen::InsensitiveStr::Ascii("usivelly"), @@ -59716,7 +111640,11 @@ pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: &[ @@ -59725,12 +111653,16 @@ pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["exclamation"], &["exclamation"], &["exclamation"], + &["exclamation"], &["exclusive"], &["exclusives"], &["exclusivity"], + &["exclude"], &["excludes"], - &["excludes"], + &["excluding"], + &["excludes", "exclude", "excuse", "exclusive"], &["exclusives"], + &["exclusive"], &["exclusives"], &["exclusivity"], &["exclusively"], @@ -59743,6 +111675,10 @@ pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["exclusives"], &["exclusivity"], &["exclusivity"], + &["exclusively"], + &["exclusives"], + &["exclusive"], + &["exclusively"], &["exclusives"], &["exclusives"], ], @@ -59756,11 +111692,22 @@ static WORD_EXCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_EXCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ation"), + dictgen::InsensitiveStr::Ascii("st"), dictgen::InsensitiveStr::Ascii("sted"), + dictgen::InsensitiveStr::Ascii("sting"), dictgen::InsensitiveStr::Ascii("timent"), + dictgen::InsensitiveStr::Ascii("tment"), ], - values: &[&["existed"], &["excitement"]], - range: 4..=6, + values: &[ + &["excitation"], + &["exist"], + &["existed"], + &["existing"], + &["excitement"], + &["excitement"], + ], + range: 2..=6, }; static WORD_EXCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -59770,61 +111717,463 @@ static WORD_EXCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["exchanging"], &["exchanges"], &["exchanges"]], - range: 5..=7, + 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::Flat(&WORD_EXCE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_EXCE_CHILDREN), value: None, }; -pub static WORD_EXCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("cute"), - dictgen::InsensitiveStr::Ascii("cuted"), - dictgen::InsensitiveStr::Ascii("cutes"), - dictgen::InsensitiveStr::Ascii("cuting"), - dictgen::InsensitiveStr::Ascii("cution"), - dictgen::InsensitiveStr::Ascii("dded"), - dictgen::InsensitiveStr::Ascii("edigly"), - dictgen::InsensitiveStr::Ascii("edinly"), - dictgen::InsensitiveStr::Ascii("lent"), - dictgen::InsensitiveStr::Ascii("ll"), - dictgen::InsensitiveStr::Ascii("llance"), - dictgen::InsensitiveStr::Ascii("llant"), - dictgen::InsensitiveStr::Ascii("llenet"), - dictgen::InsensitiveStr::Ascii("llenze"), - dictgen::InsensitiveStr::Ascii("lls"), - dictgen::InsensitiveStr::Ascii("pcional"), - dictgen::InsensitiveStr::Ascii("prt"), - dictgen::InsensitiveStr::Ascii("ptin"), - dictgen::InsensitiveStr::Ascii("ptionaly"), - dictgen::InsensitiveStr::Ascii("ptionel"), - dictgen::InsensitiveStr::Ascii("ptionnal"), - dictgen::InsensitiveStr::Ascii("rcise"), - dictgen::InsensitiveStr::Ascii("rise"), - dictgen::InsensitiveStr::Ascii("rised"), - dictgen::InsensitiveStr::Ascii("rises"), - dictgen::InsensitiveStr::Ascii("rising"), - dictgen::InsensitiveStr::Ascii("ssivley"), - dictgen::InsensitiveStr::Ascii("ssivly"), - dictgen::InsensitiveStr::Ascii("uting"), - dictgen::InsensitiveStr::Ascii("utioner"), + 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"], - &["exceedingly"], - &["exceedingly"], + &["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"), + ], + values: &[ + &["exercise"], + &["exercised"], + &["exerciser"], + &["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("ions"), + dictgen::InsensitiveStr::Ascii("rt"), + 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"], + &["exceptions"], + &["excerpt"], + &["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"], @@ -59832,23 +112181,159 @@ pub static WORD_EXCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["excellence"], &["excellence"], &["excels"], - &["exceptional"], - &["excerpt"], - &["exceptions"], - &["exceptionally"], - &["exceptional"], - &["exceptional"], - &["exercise"], - &["exercise"], - &["exercised"], - &["exercises"], - &["exercising"], - &["excessively"], - &["excessively"], - &["executing"], - &["executioner"], ], - range: 2..=8, + 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"), + ], + values: &[&["exceedingly"], &["exceedingly"]], + range: 5..=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"), + ], + values: &[ + &["exceeded"], + &["exceeding"], + &["exceed"], + &["exceeded"], + &["exceeded"], + &["exceeds"], + &["exceeding"], + ], + 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 { @@ -59859,190 +112344,546 @@ static WORD_EXCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("pes"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("ting"), dictgen::InsensitiveStr::Ascii("tly"), ], values: &[ &["exact"], + &["exactly"], + &["exchange"], + &["exchange"], &["exchanges"], &["exclamation"], &["exchange"], + &["escape"], + &["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"), + ], + values: &[ + &["exhausted"], + &["exhausting"], + &["exhaustion"], + &["exhausted"], + ], + range: 4..=6, +}; + +static WORD_EXAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_EXAT_CHILDREN), + value: None, +}; + +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"), + ], + values: &[&["exactly"], &["exactly"], &["exalted"]], + range: 3..=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("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"], + &["example"], + &["examples"], + &["example"], + &["examples"], + &["expands"], + &["expansion"], + &["expansions"], + &["expansive"], + ], + range: 2..=6, +}; + +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("inining"), + dictgen::InsensitiveStr::Ascii("les"), + 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("pt"), + ], + values: &[ + &["example"], + &["examples"], + &["examined"], + &["examine", "examining"], + &["examined"], + &["examined"], + &["examined"], + &["examining"], + &["examining"], + &["examples"], + &["example"], + &["examples"], + &["example"], + &["examples"], + &["examples"], + &["example", "examples"], + &["examples"], + &["exempt"], + ], range: 2..=7, }; -static WORD_EXA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_EXA_CHILDREN), +static WORD_EXAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_EXAH_CHILDREN), value: None, }; -pub static WORD_EXA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_EXAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("carbated"), - dictgen::InsensitiveStr::Ascii("cberate"), - dictgen::InsensitiveStr::Ascii("cberated"), - dictgen::InsensitiveStr::Ascii("clty"), - dictgen::InsensitiveStr::Ascii("gerate"), - dictgen::InsensitiveStr::Ascii("gerated"), - dictgen::InsensitiveStr::Ascii("gerates"), - dictgen::InsensitiveStr::Ascii("gerating"), + 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("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("gerrated"), - dictgen::InsensitiveStr::Ascii("gerrates"), - dictgen::InsensitiveStr::Ascii("gerrating"), - dictgen::InsensitiveStr::Ascii("ggarate"), - dictgen::InsensitiveStr::Ascii("ggarated"), - dictgen::InsensitiveStr::Ascii("ggarating"), - dictgen::InsensitiveStr::Ascii("ggaration"), - dictgen::InsensitiveStr::Ascii("ggareted"), - dictgen::InsensitiveStr::Ascii("ggeratin"), - dictgen::InsensitiveStr::Ascii("ggeratted"), - dictgen::InsensitiveStr::Ascii("ggeratting"), - dictgen::InsensitiveStr::Ascii("ggerrate"), - dictgen::InsensitiveStr::Ascii("ggurate"), - dictgen::InsensitiveStr::Ascii("ggurated"), - dictgen::InsensitiveStr::Ascii("ggurating"), - dictgen::InsensitiveStr::Ascii("gguration"), - dictgen::InsensitiveStr::Ascii("hust"), - dictgen::InsensitiveStr::Ascii("husted"), - dictgen::InsensitiveStr::Ascii("husting"), - dictgen::InsensitiveStr::Ascii("hustion"), - dictgen::InsensitiveStr::Ascii("minated"), - dictgen::InsensitiveStr::Ascii("mind"), - dictgen::InsensitiveStr::Ascii("minerad"), - dictgen::InsensitiveStr::Ascii("mpt"), - dictgen::InsensitiveStr::Ascii("pansion"), - dictgen::InsensitiveStr::Ascii("pnds"), - dictgen::InsensitiveStr::Ascii("pnsions"), - dictgen::InsensitiveStr::Ascii("pnsive"), - dictgen::InsensitiveStr::Ascii("rcebated"), - dictgen::InsensitiveStr::Ascii("tled"), - dictgen::InsensitiveStr::Ascii("uhsted"), - dictgen::InsensitiveStr::Ascii("uhsting"), - dictgen::InsensitiveStr::Ascii("uhstion"), + dictgen::InsensitiveStr::Ascii("gurate"), + dictgen::InsensitiveStr::Ascii("gurated"), + dictgen::InsensitiveStr::Ascii("gurating"), + dictgen::InsensitiveStr::Ascii("guration"), + ], + values: &[ + &["exaggerate"], + &["exaggerated"], + &["exaggerates"], + &["exaggerating"], + &["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"], - &["exaggerate"], - &["exaggerated"], - &["exaggerates"], - &["exaggerating"], - &["exaggerate"], - &["exaggerated"], - &["exaggerates"], - &["exaggerating"], - &["exaggerate"], - &["exaggerated"], - &["exaggerating"], - &["exaggeration"], - &["exaggerate"], - &["exaggeration"], - &["exaggerated"], - &["exaggerating"], - &["exaggerate"], - &["exaggerate"], - &["exaggerated"], - &["exaggerating"], - &["exaggeration"], - &["exhaust"], - &["exhausted"], - &["exhausting"], - &["exhaustion"], - &["examined"], - &["examined"], - &["examined"], - &["exempt"], - &["expansion"], - &["expands"], - &["expansions"], - &["expansive"], - &["exacerbated"], - &["exalted"], - &["exhausted"], - &["exhausting"], - &["exhaustion"], + &["exactly"], + &["exactly"], + &["exactly"], + &["executable"], ], - range: 3..=10, + range: 2..=7, }; -static WORD_EV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_EV_CHILDREN), +static WORD_EW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_EW_CHILDREN), value: None, }; -pub static WORD_EV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aluacion"), - dictgen::InsensitiveStr::Ascii("aluatiing"), - dictgen::InsensitiveStr::Ascii("aluationg"), - dictgen::InsensitiveStr::Ascii("alutaion"), - dictgen::InsensitiveStr::Ascii("angalical"), - dictgen::InsensitiveStr::Ascii("angelia"), - dictgen::InsensitiveStr::Ascii("angelikal"), - dictgen::InsensitiveStr::Ascii("angers"), - dictgen::InsensitiveStr::Ascii("aulating"), - dictgen::InsensitiveStr::Ascii("aulation"), - dictgen::InsensitiveStr::Ascii("elation"), - dictgen::InsensitiveStr::Ascii("elutionary"), - dictgen::InsensitiveStr::Ascii("engalical"), - dictgen::InsensitiveStr::Ascii("enhtually"), - dictgen::InsensitiveStr::Ascii("enlopes"), - dictgen::InsensitiveStr::Ascii("entally"), - dictgen::InsensitiveStr::Ascii("entaully"), - dictgen::InsensitiveStr::Ascii("entially"), - dictgen::InsensitiveStr::Ascii("entualy"), - dictgen::InsensitiveStr::Ascii("erets"), - dictgen::InsensitiveStr::Ascii("erset"), - dictgen::InsensitiveStr::Ascii("erthing"), - dictgen::InsensitiveStr::Ascii("ertyime"), - dictgen::InsensitiveStr::Ascii("erwhere"), - dictgen::InsensitiveStr::Ascii("eryoens"), - dictgen::InsensitiveStr::Ascii("eryonehas"), - dictgen::InsensitiveStr::Ascii("eryoneis"), - dictgen::InsensitiveStr::Ascii("eryonelse"), - dictgen::InsensitiveStr::Ascii("eryons"), - dictgen::InsensitiveStr::Ascii("eryteim"), - dictgen::InsensitiveStr::Ascii("erytiem"), - dictgen::InsensitiveStr::Ascii("eryting"), - dictgen::InsensitiveStr::Ascii("eyr"), - dictgen::InsensitiveStr::Ascii("eyrones"), - dictgen::InsensitiveStr::Ascii("idencd"), - dictgen::InsensitiveStr::Ascii("idende"), - dictgen::InsensitiveStr::Ascii("identally"), - dictgen::InsensitiveStr::Ascii("loved"), - dictgen::InsensitiveStr::Ascii("loves"), - dictgen::InsensitiveStr::Ascii("loving"), - dictgen::InsensitiveStr::Ascii("olutionairy"), - dictgen::InsensitiveStr::Ascii("olutionarilly"), - dictgen::InsensitiveStr::Ascii("olutionarly"), - dictgen::InsensitiveStr::Ascii("olutionnary"), - dictgen::InsensitiveStr::Ascii("olveds"), - dictgen::InsensitiveStr::Ascii("olveos"), - dictgen::InsensitiveStr::Ascii("ovled"), - dictgen::InsensitiveStr::Ascii("ovles"), - dictgen::InsensitiveStr::Ascii("ovling"), - dictgen::InsensitiveStr::Ascii("reyones"), - dictgen::InsensitiveStr::Ascii("reytime"), + 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: &[ - &["evaluation"], - &["evaluating"], - &["evaluating"], - &["evaluation"], - &["evangelical"], - &["evangelical"], - &["evangelical"], - &["avengers"], - &["evaluating"], - &["evaluation"], - &["elevation"], + &["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("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"], + &["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")], + values: &[&["event"]], + 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"), + ], + values: &[&["evolved"], &["evolves"], &["evolving"]], + range: 4..=5, +}; + +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("tion"), + ], + values: &[ + &["evidenced"], + &["evidenced"], + &["evidently"], + &["environment"], + &["environments"], + &["eviction"], + ], + range: 4..=8, +}; + +static WORD_EVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_EVE_CHILDREN), + value: None, +}; + +pub static WORD_EVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("lation"), + dictgen::InsensitiveStr::Ascii("lope"), + dictgen::InsensitiveStr::Ascii("lutionary"), + dictgen::InsensitiveStr::Ascii("m"), + dictgen::InsensitiveStr::Ascii("ngalical"), + dictgen::InsensitiveStr::Ascii("nhtually"), + dictgen::InsensitiveStr::Ascii("nlopes"), + dictgen::InsensitiveStr::Ascii("ntally"), + dictgen::InsensitiveStr::Ascii("ntaully"), + dictgen::InsensitiveStr::Ascii("ntially"), + dictgen::InsensitiveStr::Ascii("ntuall"), + dictgen::InsensitiveStr::Ascii("ntualy"), + dictgen::InsensitiveStr::Ascii("nually"), + dictgen::InsensitiveStr::Ascii("rage"), + dictgen::InsensitiveStr::Ascii("raged"), + dictgen::InsensitiveStr::Ascii("rbody"), + dictgen::InsensitiveStr::Ascii("rets"), + dictgen::InsensitiveStr::Ascii("rithing"), + dictgen::InsensitiveStr::Ascii("rone"), + dictgen::InsensitiveStr::Ascii("rset"), + dictgen::InsensitiveStr::Ascii("rthing"), + dictgen::InsensitiveStr::Ascii("rtyime"), + dictgen::InsensitiveStr::Ascii("rtything"), + dictgen::InsensitiveStr::Ascii("rwhere"), + dictgen::InsensitiveStr::Ascii("rybodies"), + dictgen::InsensitiveStr::Ascii("ryhing"), + dictgen::InsensitiveStr::Ascii("ryoens"), + dictgen::InsensitiveStr::Ascii("ryonehas"), + dictgen::InsensitiveStr::Ascii("ryoneis"), + dictgen::InsensitiveStr::Ascii("ryonelse"), + dictgen::InsensitiveStr::Ascii("ryons"), + dictgen::InsensitiveStr::Ascii("ryteim"), + dictgen::InsensitiveStr::Ascii("rythig"), + dictgen::InsensitiveStr::Ascii("rythign"), + dictgen::InsensitiveStr::Ascii("rythin"), + dictgen::InsensitiveStr::Ascii("rythings"), + dictgen::InsensitiveStr::Ascii("rytiem"), + dictgen::InsensitiveStr::Ascii("ryting"), + dictgen::InsensitiveStr::Ascii("yone"), + dictgen::InsensitiveStr::Ascii("yr"), + dictgen::InsensitiveStr::Ascii("yrones"), + ], + values: &[ + &["elevation"], + &["envelope", "envelop"], + &["evolutionary"], + &["even", "ever"], &["evangelical"], &["eventually"], &["envelopes"], @@ -60050,40 +112891,127 @@ pub static WORD_EV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["eventually"], &["eventually"], &["eventually"], + &["eventually"], + &["eventually"], + &["average"], + &["averaged"], + &["everybody"], &["everest"], + &["everything"], + &["everyone"], &["everest"], &["everything"], &["everytime"], + &["everything"], &["everywhere"], + &["everybody"], + &["everything"], &["everyones"], &["everyones"], &["everyones"], &["everyones"], &["everyones"], &["everytime"], - &["everytime"], &["everything"], + &["everything"], + &["everything"], + &["everything"], + &["everytime"], + &["everything"], + &["everyone"], &["every"], &["everyones"], - &["evidenced"], - &["evidenced"], - &["evidently"], - &["evolved"], - &["evolves"], - &["evolving"], - &["evolutionary"], - &["evolutionary"], - &["evolutionary"], - &["evolutionary"], - &["evolves"], - &["evolves"], - &["evolved"], - &["evolves"], - &["evolving"], - &["everyones"], - &["everytime"], ], - range: 3..=13, + range: 1..=9, +}; + +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("lation"), + dictgen::InsensitiveStr::Ascii("luacion"), + dictgen::InsensitiveStr::Ascii("luataion"), + dictgen::InsensitiveStr::Ascii("luataions"), + dictgen::InsensitiveStr::Ascii("luatiing"), + dictgen::InsensitiveStr::Ascii("luationg"), + dictgen::InsensitiveStr::Ascii("lueate"), + dictgen::InsensitiveStr::Ascii("lueated"), + dictgen::InsensitiveStr::Ascii("luete"), + dictgen::InsensitiveStr::Ascii("lueted"), + dictgen::InsensitiveStr::Ascii("lulates"), + dictgen::InsensitiveStr::Ascii("lutaion"), + dictgen::InsensitiveStr::Ascii("lutaions"), + dictgen::InsensitiveStr::Ascii("lutate"), + dictgen::InsensitiveStr::Ascii("lutated"), + dictgen::InsensitiveStr::Ascii("lutates"), + dictgen::InsensitiveStr::Ascii("lutating"), + dictgen::InsensitiveStr::Ascii("lutation"), + dictgen::InsensitiveStr::Ascii("lute"), + dictgen::InsensitiveStr::Ascii("luted"), + dictgen::InsensitiveStr::Ascii("lutes"), + dictgen::InsensitiveStr::Ascii("luting"), + dictgen::InsensitiveStr::Ascii("lution"), + 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: &[ + &["evaluation"], + &["evaluation"], + &["evaluation"], + &["evaluations"], + &["evaluating"], + &["evaluating"], + &["evaluate"], + &["evaluated"], + &["evaluate"], + &["evaluated"], + &["evaluates"], + &["evaluation"], + &["evaluations"], + &["evaluate"], + &["evaluated"], + &["evaluates"], + &["evaluating"], + &["evaluation"], + &["evaluate"], + &["evaluated"], + &["evaluates"], + &["evaluating"], + &["evaluation", "evolution"], + &["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 { @@ -60098,6 +113026,8 @@ pub static WORD_EU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -60108,6 +113038,10 @@ pub static WORD_EU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -60127,6 +113061,8 @@ pub static WORD_EU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["eugenics"], &["euphoria"], &["euphoric"], + &["equivalent"], + &["equivalents"], &["european"], &["europeans"], &["euphoria"], @@ -60137,6 +113073,10 @@ pub static WORD_EU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["euphoric"], &["euphoria"], &["euphoric"], + &["equivalent"], + &["equivalents"], + &["heuristic"], + &["heuristics"], &["europeans"], &["europeans"], &["european"], @@ -60160,9 +113100,24 @@ static WORD_ET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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("hicallity"), dictgen::InsensitiveStr::Ascii("hicallly"), @@ -60178,15 +113133,40 @@ pub static WORD_ET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("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"], + &["etc"], + &["extend", "attend"], + &["extended", "attended"], + &["extender", "attender"], + &["extenders", "attenders"], + &["extends", "attends"], + &["extensible"], + &["extension"], + &["extensions"], &["ethically"], + &["the"], &["ethereal"], &["ethereal"], &["ethernet"], + &["ethernet"], &["ethically"], &["ethically"], &["ethically"], @@ -60200,12 +113180,22 @@ pub static WORD_ET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["ethnicities"], &["ethnicity"], &["ethnocentrism"], - &["those"], + &["those", "ethos"], + &["either"], &["etiquette"], &["etymology"], &["retailer"], + &["erroneous"], + &["erroneously"], + &["error", "terror"], + &["errors", "terrors"], + &["establishment"], + &["establishment"], + &["test"], + &["tests"], + &["text"], ], - range: 4..=11, + range: 2..=11, }; static WORD_ES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60214,13 +113204,13 @@ static WORD_ES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_ESA_NODE), None, Some(&WORD_ESC_NODE), None, Some(&WORD_ESE_NODE), None, - None, + Some(&WORD_ESG_NODE), None, Some(&WORD_ESI_NODE), None, @@ -60238,10 +113228,21 @@ static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, 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_EST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_EST_CHILDREN), value: None, @@ -60249,18 +113250,27 @@ static WORD_EST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -60269,18 +113279,27 @@ pub static WORD_EST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("oniya"), ], values: &[ + &["establish"], &["establishments"], + &["establish"], + &["established"], + &["established"], &["establishes"], - &["establishments"], - &["establishments"], - &["establishments"], &["establishing"], &["establishments"], &["establishments"], + &["establishments"], + &["establishes"], + &["establishing"], + &["established"], + &["establishments"], + &["establishments", "establishment"], &["estimate"], &["estimated"], &["estimates"], &["estimation"], + &["estimate"], + &["estimates"], &["estimation"], &["estimation"], &["estimation"], @@ -60298,6 +113317,7 @@ static WORD_ESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -60306,6 +113326,8 @@ pub static WORD_ESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("entail"), dictgen::InsensitiveStr::Ascii("entailly"), dictgen::InsensitiveStr::Ascii("entails"), + dictgen::InsensitiveStr::Ascii("entaily"), + dictgen::InsensitiveStr::Ascii("entiall"), dictgen::InsensitiveStr::Ascii("entialls"), dictgen::InsensitiveStr::Ascii("entialy"), dictgen::InsensitiveStr::Ascii("entias"), @@ -60313,9 +113335,15 @@ pub static WORD_ESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -60324,6 +113352,8 @@ pub static WORD_ESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["essential"], &["essentially"], &["essentials"], + &["essentially"], + &["essential", "essentially"], &["essentials"], &["essentially"], &["essentials"], @@ -60331,9 +113361,14 @@ pub static WORD_ESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["essential"], &["essentially"], &["essentials"], + &["essentially"], + &["essential"], + &["essentially"], + &["essentially"], + &["essential"], &["essential"], ], - range: 4..=8, + range: 4..=9, }; static WORD_ESP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60343,13 +113378,25 @@ static WORD_ESP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("ianoge"), dictgen::InsensitiveStr::Ascii("inoage"), dictgen::InsensitiveStr::Ascii("oinage"), + dictgen::InsensitiveStr::Ascii("onding"), dictgen::InsensitiveStr::Ascii("oniage"), dictgen::InsensitiveStr::Ascii("orst"), dictgen::InsensitiveStr::Ascii("ortes"), @@ -60360,13 +113407,25 @@ pub static WORD_ESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rots"), ], values: &[ + &["escape"], + &["escaped"], + &["escapes"], + &["especially"], + &["escaping"], &["especially"], &["especially"], &["especially"], + &["especially"], + &["especially"], + &["specifically", "especially"], + &["especially"], + &["expect"], + &["especially"], &["separate"], &["espionage"], &["espionage"], &["espionage"], + &["desponding", "responding"], &["espionage"], &["esports"], &["esports"], @@ -60376,7 +113435,7 @@ pub static WORD_ESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["espresso"], &["esports"], ], - range: 4..=7, + range: 3..=10, }; static WORD_ESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60411,18 +113470,39 @@ static WORD_ESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("est"), + dictgen::InsensitiveStr::Ascii("sts"), dictgen::InsensitiveStr::Ascii("tmate"), dictgen::InsensitiveStr::Ascii("tmated"), dictgen::InsensitiveStr::Ascii("tmates"), dictgen::InsensitiveStr::Ascii("tmation"), ], values: &[ + &["easiest"], + &["exists"], &["estimate"], &["estimated"], &["estimates"], &["estimation"], ], - range: 5..=7, + range: 3..=7, +}; + +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 { @@ -60431,9 +113511,13 @@ static WORD_ESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ntial")], - values: &[&["essential"]], - range: 5..=5, + 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 { @@ -60447,8 +113531,15 @@ pub static WORD_ESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("alatin"), dictgen::InsensitiveStr::Ascii("alative"), dictgen::InsensitiveStr::Ascii("alato"), + dictgen::InsensitiveStr::Ascii("apeable"), + dictgen::InsensitiveStr::Ascii("apemant"), dictgen::InsensitiveStr::Ascii("apse"), + dictgen::InsensitiveStr::Ascii("ased"), dictgen::InsensitiveStr::Ascii("avation"), + dictgen::InsensitiveStr::Ascii("cape"), + dictgen::InsensitiveStr::Ascii("caped"), + dictgen::InsensitiveStr::Ascii("pae"), + dictgen::InsensitiveStr::Ascii("paed"), dictgen::InsensitiveStr::Ascii("paes"), dictgen::InsensitiveStr::Ascii("tasy"), dictgen::InsensitiveStr::Ascii("tatic"), @@ -60458,13 +113549,35 @@ pub static WORD_ESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["escalation"], &["escalate"], &["escalation"], + &["escapable"], + &["escapement"], &["escapes"], + &["escaped"], &["escalation"], + &["escape"], + &["escaped"], + &["escape"], + &["escaped"], &["escapes"], &["ecstasy"], &["ecstatic"], ], - range: 4..=7, + range: 3..=7, +}; + +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 { @@ -60475,88 +113588,217 @@ static WORD_ER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_ER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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("roneus"), + dictgen::InsensitiveStr::Ascii("roneusly"), + dictgen::InsensitiveStr::Ascii("ronous"), + dictgen::InsensitiveStr::Ascii("ronously"), + dictgen::InsensitiveStr::Ascii("rorneous"), + dictgen::InsensitiveStr::Ascii("rorneously"), + dictgen::InsensitiveStr::Ascii("rorneus"), + dictgen::InsensitiveStr::Ascii("rornous"), + dictgen::InsensitiveStr::Ascii("rornously"), + dictgen::InsensitiveStr::Ascii("rorr"), + 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"), ], values: &[ - &["orally"], + &["orally", "really"], + &["eraseblocks"], + &["erasure", "eraser"], &["erratic"], &["erratically"], &["erratically"], - &["arrested"], + &["arrested", "erected"], + &["performance"], + &["earlier"], + &["earlier"], + &["early"], + &["emergency"], &["remington"], &["erroneous"], + &["error"], &["erroneous"], + &["erroneously"], + &["error"], + &["errors"], + &["errors"], + &["erroneously"], + &["error"], + &["erroneous"], + &["erroneous"], + &["erroneous"], + &["erroneously"], + &["erroneous"], + &["erroneously"], + &["erroneous"], + &["erroneously"], + &["erroneous"], + &["erroneous"], + &["erroneously"], + &["error"], + &["errors"], + &["error"], + &["errors"], + &["error"], + &["error"], + &["errors"], + &["errors"], &["erupted"], + &["erroneous"], + &["erroneously"], + &["error", "terror"], + &["errors", "terrors"], + &["every"], + &["everything"], ], - range: 4..=8, + range: 2..=10, }; static WORD_EQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_EQ_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_EQ_CHILDREN), value: None, }; -pub static WORD_EQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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::Flat(&WORD_EQU_CHILDREN), + value: None, +}; + +pub static WORD_EQU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("aulity"), - dictgen::InsensitiveStr::Ascii("aution"), - dictgen::InsensitiveStr::Ascii("autions"), - dictgen::InsensitiveStr::Ascii("uailty"), - dictgen::InsensitiveStr::Ascii("uialent"), - dictgen::InsensitiveStr::Ascii("uiavlent"), - dictgen::InsensitiveStr::Ascii("uilavent"), - dictgen::InsensitiveStr::Ascii("uilavents"), - dictgen::InsensitiveStr::Ascii("uilbirium"), - dictgen::InsensitiveStr::Ascii("uilevants"), - dictgen::InsensitiveStr::Ascii("uilibirum"), - dictgen::InsensitiveStr::Ascii("uilibium"), - dictgen::InsensitiveStr::Ascii("uilibriam"), - dictgen::InsensitiveStr::Ascii("uilibrim"), - dictgen::InsensitiveStr::Ascii("uilibruim"), - dictgen::InsensitiveStr::Ascii("uilibrum"), - dictgen::InsensitiveStr::Ascii("uiped"), - dictgen::InsensitiveStr::Ascii("uippment"), - dictgen::InsensitiveStr::Ascii("uitorial"), - dictgen::InsensitiveStr::Ascii("uivalance"), - dictgen::InsensitiveStr::Ascii("uivalant"), - dictgen::InsensitiveStr::Ascii("uivalants"), - dictgen::InsensitiveStr::Ascii("uivalenet"), - dictgen::InsensitiveStr::Ascii("uivalet"), - dictgen::InsensitiveStr::Ascii("uivallent"), - dictgen::InsensitiveStr::Ascii("uivalnce"), - dictgen::InsensitiveStr::Ascii("uivalnet"), - dictgen::InsensitiveStr::Ascii("uivelance"), - dictgen::InsensitiveStr::Ascii("uivelant"), - dictgen::InsensitiveStr::Ascii("uivelants"), - dictgen::InsensitiveStr::Ascii("uivelent"), - dictgen::InsensitiveStr::Ascii("uivelents"), - dictgen::InsensitiveStr::Ascii("uivilant"), - dictgen::InsensitiveStr::Ascii("uivilants"), - dictgen::InsensitiveStr::Ascii("uivilence"), - dictgen::InsensitiveStr::Ascii("uivilent"), - dictgen::InsensitiveStr::Ascii("uivilents"), - dictgen::InsensitiveStr::Ascii("uivlaent"), - dictgen::InsensitiveStr::Ascii("uivlalent"), - dictgen::InsensitiveStr::Ascii("uivlanets"), - dictgen::InsensitiveStr::Ascii("uivolence"), - dictgen::InsensitiveStr::Ascii("uivolent"), - dictgen::InsensitiveStr::Ascii("uivolents"), + dictgen::InsensitiveStr::Ascii("ailty"), + dictgen::InsensitiveStr::Ascii("alibrium"), + dictgen::InsensitiveStr::Ascii("allity"), + dictgen::InsensitiveStr::Ascii("aly"), + dictgen::InsensitiveStr::Ascii("el"), + dictgen::InsensitiveStr::Ascii("elibrium"), + dictgen::InsensitiveStr::Ascii("ialent"), + dictgen::InsensitiveStr::Ascii("iavlent"), + dictgen::InsensitiveStr::Ascii("ilavalent"), + dictgen::InsensitiveStr::Ascii("ilavent"), + dictgen::InsensitiveStr::Ascii("ilavents"), + dictgen::InsensitiveStr::Ascii("ilbirium"), + dictgen::InsensitiveStr::Ascii("ilevants"), + dictgen::InsensitiveStr::Ascii("ilibirum"), + dictgen::InsensitiveStr::Ascii("ilibium"), + dictgen::InsensitiveStr::Ascii("ilibriam"), + dictgen::InsensitiveStr::Ascii("ilibrim"), + dictgen::InsensitiveStr::Ascii("ilibruim"), + dictgen::InsensitiveStr::Ascii("ilibrum"), + dictgen::InsensitiveStr::Ascii("iped"), + dictgen::InsensitiveStr::Ascii("ipmentd"), + dictgen::InsensitiveStr::Ascii("ipments"), + dictgen::InsensitiveStr::Ascii("ippment"), + dictgen::InsensitiveStr::Ascii("iptment"), + dictgen::InsensitiveStr::Ascii("ire"), + dictgen::InsensitiveStr::Ascii("itorial"), + dictgen::InsensitiveStr::Ascii("ivalance"), + dictgen::InsensitiveStr::Ascii("ivalant"), + dictgen::InsensitiveStr::Ascii("ivalants"), + dictgen::InsensitiveStr::Ascii("ivalenet"), + dictgen::InsensitiveStr::Ascii("ivalentsly"), + dictgen::InsensitiveStr::Ascii("ivalet"), + dictgen::InsensitiveStr::Ascii("ivallent"), + dictgen::InsensitiveStr::Ascii("ivalnce"), + dictgen::InsensitiveStr::Ascii("ivalnet"), + dictgen::InsensitiveStr::Ascii("ivelance"), + dictgen::InsensitiveStr::Ascii("ivelant"), + dictgen::InsensitiveStr::Ascii("ivelants"), + dictgen::InsensitiveStr::Ascii("ivelent"), + dictgen::InsensitiveStr::Ascii("ivelents"), + dictgen::InsensitiveStr::Ascii("ivilant"), + dictgen::InsensitiveStr::Ascii("ivilants"), + dictgen::InsensitiveStr::Ascii("ivilence"), + dictgen::InsensitiveStr::Ascii("ivilent"), + dictgen::InsensitiveStr::Ascii("ivilents"), + dictgen::InsensitiveStr::Ascii("ivivalent"), + dictgen::InsensitiveStr::Ascii("ivlaent"), + dictgen::InsensitiveStr::Ascii("ivlalent"), + dictgen::InsensitiveStr::Ascii("ivlanets"), + dictgen::InsensitiveStr::Ascii("ivlantly"), + dictgen::InsensitiveStr::Ascii("ivolence"), + dictgen::InsensitiveStr::Ascii("ivolent"), + dictgen::InsensitiveStr::Ascii("ivolents"), + dictgen::InsensitiveStr::Ascii("ivqlent"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tions"), + dictgen::InsensitiveStr::Ascii("valent"), ], values: &[ &["equality"], - &["equation"], - &["equations"], + &["equilibrium"], &["equality"], + &["equally"], + &["equal"], + &["equilibrium"], &["equivalent"], &["equivalents"], &["equivalent"], + &["equivalent"], &["equivalents"], &["equilibrium"], &["equivalents"], @@ -60568,11 +113810,16 @@ pub static WORD_EQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["equilibrium"], &["equipped"], &["equipment"], + &["equipment"], + &["equipment"], + &["equipment"], + &["require", "enquire", "equine", "esquire"], &["equatorial"], &["equivalence"], &["equivalent"], &["equivalents"], &["equivalents"], + &["equivalently", "equivalency"], &["equivalents"], &["equivalent"], &["equivalence"], @@ -60587,14 +113834,57 @@ pub static WORD_EQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["equivalence"], &["equivalent"], &["equivalents"], + &["equivalent"], &["equivalents"], &["equivalent"], &["equivalents"], + &["equivalently"], &["equivalence"], &["equivalent"], &["equivalents"], + &["equivalent"], + &["equation"], + &["equations"], + &["equivalent"], ], - range: 5..=9, + range: 2..=10, +}; + +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 { @@ -60604,8 +113894,17 @@ static WORD_EP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("hipany"), dictgen::InsensitiveStr::Ascii("idsodes"), + dictgen::InsensitiveStr::Ascii("igramic"), dictgen::InsensitiveStr::Ascii("ihpany"), dictgen::InsensitiveStr::Ascii("ilepsey"), dictgen::InsensitiveStr::Ascii("ilespy"), @@ -60618,17 +113917,37 @@ pub static WORD_EP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("sorts"), dictgen::InsensitiveStr::Ascii("sresso"), + dictgen::InsensitiveStr::Ascii("tied"), + dictgen::InsensitiveStr::Ascii("tier"), + dictgen::InsensitiveStr::Ascii("ties"), dictgen::InsensitiveStr::Ascii("tiome"), + dictgen::InsensitiveStr::Ascii("ty"), + dictgen::InsensitiveStr::Ascii("xected"), + dictgen::InsensitiveStr::Ascii("xiressions"), + dictgen::InsensitiveStr::Ascii("xlicit"), ], values: &[ + &["especifica"], + &["expect"], + &["expected"], + &["expectedly"], + &["expecting"], + &["expects"], + &["ephemeral"], + &["ephemeris"], &["epiphany"], &["episodes"], + &["epigrammatic"], &["epiphany"], &["epilepsy"], &["epilepsy"], @@ -60641,15 +113960,26 @@ pub static WORD_EP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["epitome"], &["epilepsy"], &["epilogue"], + &["exploit"], + &["exploits"], + &["empty"], + &["expressions"], &["specially"], &["episode"], &["episodes"], &["espionage"], &["esports"], &["espresso"], + &["emptied"], + &["emptier"], + &["empties"], &["epitome"], + &["empty"], + &["expected"], + &["expressions"], + &["explicit"], ], - range: 5..=7, + range: 2..=10, }; static WORD_EN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60659,7 +113989,7 @@ static WORD_EN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_ENA_NODE), - None, + Some(&WORD_ENB_NODE), Some(&WORD_ENC_NODE), Some(&WORD_END_NODE), Some(&WORD_ENE_NODE), @@ -60670,22 +114000,33 @@ static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_ENL_NODE), - None, - None, + Some(&WORD_ENM_NODE), + Some(&WORD_ENN_NODE), Some(&WORD_ENO_NODE), - None, - None, + Some(&WORD_ENP_NODE), + Some(&WORD_ENQ_NODE), Some(&WORD_ENR_NODE), Some(&WORD_ENS_NODE), Some(&WORD_ENT_NODE), - None, + Some(&WORD_ENU_NODE), Some(&WORD_ENV_NODE), None, Some(&WORD_ENX_NODE), - None, + 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("way")], + values: &[&["anyway"]], + range: 3..=3, +}; + static WORD_ENX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ENX_CHILDREN), value: None, @@ -60698,92 +114039,366 @@ pub static WORD_ENX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_ENV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ENV_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ENV_CHILDREN), value: None, }; -pub static WORD_ENV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("eloppe"), - dictgen::InsensitiveStr::Ascii("elopped"), - dictgen::InsensitiveStr::Ascii("eloppen"), - dictgen::InsensitiveStr::Ascii("eloppes"), - dictgen::InsensitiveStr::Ascii("inroment"), - dictgen::InsensitiveStr::Ascii("iorment"), - dictgen::InsensitiveStr::Ascii("iormental"), - dictgen::InsensitiveStr::Ascii("iormentally"), - dictgen::InsensitiveStr::Ascii("iorments"), - dictgen::InsensitiveStr::Ascii("iornment"), - dictgen::InsensitiveStr::Ascii("iornmental"), - dictgen::InsensitiveStr::Ascii("iornmentalist"), - dictgen::InsensitiveStr::Ascii("iornmentally"), - dictgen::InsensitiveStr::Ascii("iornments"), - dictgen::InsensitiveStr::Ascii("irnoment"), - dictgen::InsensitiveStr::Ascii("iroment"), - dictgen::InsensitiveStr::Ascii("iromental"), - dictgen::InsensitiveStr::Ascii("iromentalist"), - dictgen::InsensitiveStr::Ascii("iromentally"), - dictgen::InsensitiveStr::Ascii("iroments"), - dictgen::InsensitiveStr::Ascii("iromnent"), - dictgen::InsensitiveStr::Ascii("ironemnt"), - dictgen::InsensitiveStr::Ascii("ironemntal"), - dictgen::InsensitiveStr::Ascii("ironemntally"), - dictgen::InsensitiveStr::Ascii("ironemnts"), - dictgen::InsensitiveStr::Ascii("ironmentality"), - dictgen::InsensitiveStr::Ascii("ironmentals"), - dictgen::InsensitiveStr::Ascii("ironmentaly"), - dictgen::InsensitiveStr::Ascii("ironmentl"), - dictgen::InsensitiveStr::Ascii("ironmently"), - dictgen::InsensitiveStr::Ascii("ironmet"), - dictgen::InsensitiveStr::Ascii("ironmetal"), - dictgen::InsensitiveStr::Ascii("ironmnet"), - dictgen::InsensitiveStr::Ascii("olutionary"), - dictgen::InsensitiveStr::Ascii("rionment"), - dictgen::InsensitiveStr::Ascii("rionmental"), - dictgen::InsensitiveStr::Ascii("rionmentally"), - dictgen::InsensitiveStr::Ascii("rionments"), + 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"), + ], + values: &[ + &["environ"], + &["environment"], + &["environmental"], + &["environmentally"], + &["environments"], + &["environs"], + &["environ"], + &["environment"], + &["environmental"], + &["environments"], + &["environs"], + ], + 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("lutionary"), + dictgen::InsensitiveStr::Ascii("lved"), + dictgen::InsensitiveStr::Ascii("rce"), + ], + values: &[&["evolutionary"], &["involved"], &["enforce"]], + range: 3..=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("onent"), + dictgen::InsensitiveStr::Ascii("onmane"), + 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("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"], + &["environment"], + &["environment"], + &["environments"], + &["environmentally"], + &["environments"], + &["environmentally"], + &["environmentally"], + &["environmental"], + &["environments", "environment"], + &["environmental"], + &["environments"], + &["environments", "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("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"], + &["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")], + values: &[&["environments"]], + range: 6..=6, +}; + +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("r"), ], values: &[ &["envelope"], &["envelope"], &["envelope"], &["envelope"], - &["environments"], - &["environment"], - &["environmental"], - &["environmentally"], - &["environments"], - &["environment"], - &["environmental"], - &["environmentalist"], - &["environmentally"], - &["environments"], - &["environment"], - &["environment"], - &["environmental"], - &["environmentalist"], - &["environmentally"], - &["environments"], - &["environments"], - &["environment"], - &["environmental"], - &["environmentally"], - &["environments"], - &["environmentally"], - &["environments"], - &["environmentally"], - &["environmentally"], - &["environmental"], - &["environments"], - &["environmental"], - &["environments"], - &["evolutionary"], - &["environment"], - &["environmental"], - &["environmentally"], - &["environments"], + &["never"], ], - range: 6..=13, + range: 1..=6, +}; + +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("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("merble"), + dictgen::InsensitiveStr::Ascii("mertaion"), + dictgen::InsensitiveStr::Ascii("sre"), + ], + values: &[ + &["emulation"], + &["enumerate"], + &["enumerated"], + &["enumerates"], + &["enumerating"], + &["enumeration"], + &["enumerate"], + &["enumeration"], + &["enumerable"], + &["enumeration"], + &["ensure"], + ], + range: 3..=9, }; static WORD_ENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60808,7 +114423,7 @@ static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_ENTO_NODE), None, - None, + Some(&WORD_ENTQ_NODE), Some(&WORD_ENTR_NODE), None, None, @@ -60816,10 +114431,21 @@ static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, 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_ENTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ENTR_CHILDREN), value: None, @@ -60854,8 +114480,11 @@ pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("etained"), dictgen::InsensitiveStr::Ascii("etaining"), dictgen::InsensitiveStr::Ascii("etainment"), + dictgen::InsensitiveStr::Ascii("ie"), + dictgen::InsensitiveStr::Ascii("iy"), dictgen::InsensitiveStr::Ascii("opay"), dictgen::InsensitiveStr::Ascii("ophy"), + dictgen::InsensitiveStr::Ascii("ys"), ], values: &[ &["entrepreneur"], @@ -60885,10 +114514,36 @@ pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["entertained"], &["entertaining"], &["entertainment"], + &["entry", "entries"], + &["entry", "entries"], &["entropy"], &["entropy"], + &["entries", "entry"], ], - range: 4..=11, + 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", "enquire"], + &["enquired", "enquired"], + &["enquires", "enquires"], + &["enquiries", "enquiries"], + &["enquiry", "enquiry"], + ], + range: 4..=6, }; static WORD_ENTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60899,10 +114554,12 @@ static WORD_ENTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["intoxication"]], - range: 3..=8, + values: &[&["entropy"], &["entities"], &["entity"], &["intoxication"]], + range: 2..=8, }; static WORD_ENTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60915,25 +114572,57 @@ pub static WORD_ENTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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"), ], values: &[ &["entirely"], &["entirety"], &["entitled"], - &["entirely"], + &["entered", "entire"], &["entirety"], &["entirely"], - &["entitled"], + &["entries"], + &["entirety", "entirely"], + &["entirety"], + &["entirely"], + &["entirely"], + &["entire", "entity"], &["entity"], + &["entities"], &["entitled"], + &["entities"], + &["entity"], + &["entity"], + &["entities"], + &["entities"], + &["entity"], + &["entity"], + &["entities"], + &["entitled"], + &["entities"], ], - range: 3..=5, + range: 2..=6, }; static WORD_ENTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -60948,6 +114637,7 @@ pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -60980,6 +114670,7 @@ pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["ethnicity"], &["enthusiast"], &["enthusiasts"], + &["enthusiasm"], &["enthusiasts"], &["enthusiast"], &["enthusiasts"], @@ -61016,7 +114707,14 @@ static WORD_ENTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("nded"), + dictgen::InsensitiveStr::Ascii("nsion"), + dictgen::InsensitiveStr::Ascii("nsions"), + dictgen::InsensitiveStr::Ascii("ntries"), + dictgen::InsensitiveStr::Ascii("rance"), dictgen::InsensitiveStr::Ascii("ratinment"), + dictgen::InsensitiveStr::Ascii("reing"), + dictgen::InsensitiveStr::Ascii("rily"), dictgen::InsensitiveStr::Ascii("rity"), dictgen::InsensitiveStr::Ascii("rpirse"), dictgen::InsensitiveStr::Ascii("rpirses"), @@ -61037,9 +114735,19 @@ pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: &[ + &["intended"], + &["extension"], + &["extensions"], + &["entries"], + &["entrance"], &["entertainment"], + &["entering"], + &["entirely"], &["entirety"], &["enterprise"], &["enterprises"], @@ -61060,8 +114768,11 @@ pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["entertained"], &["entertainment"], &["entertained"], + &["entry"], + &["entities"], + &["entity"], ], - range: 4..=9, + range: 2..=9, }; static WORD_ENTB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61113,9 +114824,39 @@ pub static WORD_ENR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("olement"), dictgen::InsensitiveStr::Ascii("ollemnt"), + dictgen::InsensitiveStr::Ascii("ties"), + dictgen::InsensitiveStr::Ascii("ty"), ], - values: &[&["enrollment"], &["enrollment"]], - range: 7..=7, + values: &[&["enrollment"], &["enrollment"], &["entries"], &["entry"]], + 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 { @@ -61125,11 +114866,120 @@ static WORD_ENO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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: &[&["enormous"], &["enormously"]], - range: 6..=8, + values: &[ + &["encode"], + &["encoded"], + &["encoder"], + &["encoders"], + &["encodes"], + &["encoding"], + &["encodings"], + &["enough"], + &["enough"], + &["enough"], + &["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"), + ], + values: &[&["empty"], &["enum"]], + range: 2..=3, }; static WORD_ENL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61153,11 +115003,13 @@ pub static WORD_ENL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], @@ -61176,11 +115028,13 @@ pub static WORD_ENL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["enlightening"], &["enlightened"], &["enlightenment"], + &["enlightenment"], &["enlighten"], &["enlightened"], &["enlightening"], &["enlightenment"], - &["english"], + &["english", "enlist"], + &["enclose"], &["enslave"], &["enslaved"], ], @@ -61195,17 +115049,33 @@ static WORD_ENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("trely"), + dictgen::InsensitiveStr::Ascii("ty"), dictgen::InsensitiveStr::Ascii("vitable"), + dictgen::InsensitiveStr::Ascii("vornment"), + dictgen::InsensitiveStr::Ascii("vornments"), dictgen::InsensitiveStr::Ascii("vronmentally"), ], values: &[ &["engineer"], + &["environment"], + &["environments"], + &["entities"], + &["entities"], + &["entity"], &["entirely"], + &["entity"], &["inevitable"], + &["environment"], + &["environments"], &["environmentally"], ], - range: 5..=12, + range: 2..=12, }; static WORD_ENH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61215,12 +115085,52 @@ static WORD_ENH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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: &[&["enhancing"], &["enhances"], &["enhances"]], - range: 4..=6, + values: &[ + &["enhance"], + &["enhanced"], + &["enhances"], + &["enhancing"], + &["enhance"], + &["enhanced"], + &["enhancement"], + &["enhancements"], + &["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 { @@ -61238,6 +115148,8 @@ pub static WORD_ENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("eneer"), dictgen::InsensitiveStr::Ascii("eneering"), dictgen::InsensitiveStr::Ascii("eries"), + dictgen::InsensitiveStr::Ascii("ery"), + dictgen::InsensitiveStr::Ascii("ieer"), dictgen::InsensitiveStr::Ascii("ieneer"), dictgen::InsensitiveStr::Ascii("ieneers"), dictgen::InsensitiveStr::Ascii("ineed"), @@ -61246,8 +115158,11 @@ pub static WORD_ENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("iner"), dictgen::InsensitiveStr::Ascii("inereed"), dictgen::InsensitiveStr::Ascii("inerring"), + dictgen::InsensitiveStr::Ascii("inge"), + dictgen::InsensitiveStr::Ascii("inin"), dictgen::InsensitiveStr::Ascii("innering"), dictgen::InsensitiveStr::Ascii("lsih"), + dictgen::InsensitiveStr::Ascii("oug"), dictgen::InsensitiveStr::Ascii("rames"), dictgen::InsensitiveStr::Ascii("ramms"), ], @@ -61260,6 +115175,8 @@ pub static WORD_ENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["engineer"], &["engineering"], &["energies"], + &["energy"], + &["engineer"], &["engineer"], &["engineers"], &["engineered"], @@ -61268,12 +115185,15 @@ pub static WORD_ENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["engineer"], &["engineered"], &["engineering"], + &["engine"], + &["engine"], &["engineering"], &["english"], + &["enough"], &["engrams"], &["engrams"], ], - range: 4..=8, + range: 3..=8, }; static WORD_ENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61283,14 +115203,24 @@ static WORD_ENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("orncing"), dictgen::InsensitiveStr::Ascii("orse"), dictgen::InsensitiveStr::Ascii("ringement"), ], values: &[ + &["inflamed"], + &["enforceable"], &["enforces"], &["enforcing"], + &["enforcement"], + &["enforcement"], + &["enforcing"], &["enforces"], &["infringement"], ], @@ -61304,13 +115234,52 @@ static WORD_ENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ables"), + dictgen::InsensitiveStr::Ascii("bale"), + dictgen::InsensitiveStr::Ascii("baled"), + 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("rgis"), + dictgen::InsensitiveStr::Ascii("ry"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("tered"), + 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: &[&["need"], &["unemployment"], &["energies"], &["envelopes"]], - range: 1..=9, + values: &[ + &["enables"], + &["enable"], + &["enabled"], + &["enable"], + &["need"], + &["energies"], + &["energy"], + &["enhanced"], + &["unemployment"], + &["energies"], + &["energy"], + &["enter"], + &["entered"], + &["entities"], + &["entity"], + &["enumeration"], + &["enumerations"], + &["enumeration"], + &["enumerations"], + &["envelopes"], + &["new"], + ], + range: 1..=10, }; static WORD_END_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61324,19 +115293,39 @@ pub static WORD_END_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("evors"), dictgen::InsensitiveStr::Ascii("evour"), + dictgen::InsensitiveStr::Ascii("fi"), + dictgen::InsensitiveStr::Ascii("ianes"), + dictgen::InsensitiveStr::Ascii("ianess"), + dictgen::InsensitiveStr::Ascii("iannes"), + dictgen::InsensitiveStr::Ascii("ien"), + dictgen::InsensitiveStr::Ascii("iens"), dictgen::InsensitiveStr::Ascii("ig"), 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("olithes"), dictgen::InsensitiveStr::Ascii("orcement"), dictgen::InsensitiveStr::Ascii("orces"), dictgen::InsensitiveStr::Ascii("ores"), dictgen::InsensitiveStr::Ascii("oresment"), dictgen::InsensitiveStr::Ascii("oresments"), + dictgen::InsensitiveStr::Ascii("pints"), + dictgen::InsensitiveStr::Ascii("piont"), + dictgen::InsensitiveStr::Ascii("pionts"), + dictgen::InsensitiveStr::Ascii("pont"), dictgen::InsensitiveStr::Ascii("rose"), dictgen::InsensitiveStr::Ascii("uce"), ], @@ -61345,23 +115334,43 @@ pub static WORD_END_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["endangering"], &["endangered"], &["endangered"], + &["encoded"], + &["encoder"], + &["encoders"], + &["encodes"], + &["encoding"], + &["encodings"], + &["ending"], + &["end"], &["endeavors"], &["endeavour"], + &["endif"], + &["endianness"], + &["endianness"], + &["endianness"], + &["endian", "indian"], + &["endians", "indians"], &["ending"], &["endlessly"], &["endlessly"], + &["endnode"], &["indoctrinated"], &["indoctrination"], + &["endpoint"], &["endoliths"], &["endorsement"], &["endorse"], &["endorse"], &["endorsement"], &["endorsement"], + &["endpoints"], + &["endpoint"], + &["endpoints"], + &["endpoint"], &["endorse"], &["induce"], ], - range: 2..=11, + range: 1..=11, }; static WORD_ENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61390,7 +115399,7 @@ static WORD_ENC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_ENCR_NODE), None, None, - None, + Some(&WORD_ENCU_NODE), None, None, None, @@ -61420,6 +115429,8 @@ pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -61440,6 +115451,8 @@ pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["encyclopedia"], &["encyclopedia"], &["encyclopedia"], + &["encrypted"], + &["encryption"], &["encrypt"], &["encrypted"], &["encryption"], @@ -61447,6 +115460,17 @@ pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -61454,22 +115478,44 @@ static WORD_ENCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_ENCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cypt"), + dictgen::InsensitiveStr::Ascii("ipted"), dictgen::InsensitiveStr::Ascii("iption"), + dictgen::InsensitiveStr::Ascii("pt"), + dictgen::InsensitiveStr::Ascii("pted"), + dictgen::InsensitiveStr::Ascii("ption"), dictgen::InsensitiveStr::Ascii("pyt"), dictgen::InsensitiveStr::Ascii("pyted"), dictgen::InsensitiveStr::Ascii("pytion"), + dictgen::InsensitiveStr::Ascii("upted"), + dictgen::InsensitiveStr::Ascii("ypiton"), + dictgen::InsensitiveStr::Ascii("ypte"), dictgen::InsensitiveStr::Ascii("yptiion"), + dictgen::InsensitiveStr::Ascii("yptio"), + dictgen::InsensitiveStr::Ascii("yptiong"), + dictgen::InsensitiveStr::Ascii("ytion"), dictgen::InsensitiveStr::Ascii("ytped"), ], values: &[ + &["encrypt"], + &["encrypted"], &["encryption"], &["encrypt"], &["encrypted"], &["encryption"], + &["encrypt"], + &["encrypted"], + &["encryption"], + &["encrypted"], + &["encryption"], + &["encrypted", "encrypt"], + &["encryption"], + &["encryption"], + &["encryption"], &["encryption"], &["encrypted"], ], - range: 3..=7, + range: 2..=7, }; static WORD_ENCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61479,6 +115525,13 @@ static WORD_ENCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_ENCO_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("lsed"), dictgen::InsensitiveStr::Ascii("lsure"), dictgen::InsensitiveStr::Ascii("mapsses"), @@ -61486,18 +115539,52 @@ pub static WORD_ENCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("mpases"), dictgen::InsensitiveStr::Ascii("mpasess"), dictgen::InsensitiveStr::Ascii("mpesses"), + dictgen::InsensitiveStr::Ascii("nde"), + dictgen::InsensitiveStr::Ascii("nded"), + dictgen::InsensitiveStr::Ascii("nder"), + dictgen::InsensitiveStr::Ascii("nders"), + dictgen::InsensitiveStr::Ascii("ndes"), + dictgen::InsensitiveStr::Ascii("nding"), + dictgen::InsensitiveStr::Ascii("ndings"), + dictgen::InsensitiveStr::Ascii("rde"), + dictgen::InsensitiveStr::Ascii("rded"), + dictgen::InsensitiveStr::Ascii("rder"), + dictgen::InsensitiveStr::Ascii("rders"), + dictgen::InsensitiveStr::Ascii("rdes"), + dictgen::InsensitiveStr::Ascii("rding"), + dictgen::InsensitiveStr::Ascii("rdings"), dictgen::InsensitiveStr::Ascii("rporated"), dictgen::InsensitiveStr::Ascii("rporating"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("sed"), + dictgen::InsensitiveStr::Ascii("ser"), + dictgen::InsensitiveStr::Ascii("sers"), + dictgen::InsensitiveStr::Ascii("ses"), + dictgen::InsensitiveStr::Ascii("sing"), + dictgen::InsensitiveStr::Ascii("sings"), + dictgen::InsensitiveStr::Ascii("sure"), dictgen::InsensitiveStr::Ascii("unted"), dictgen::InsensitiveStr::Ascii("unterd"), dictgen::InsensitiveStr::Ascii("unteres"), dictgen::InsensitiveStr::Ascii("untred"), dictgen::InsensitiveStr::Ascii("urageing"), dictgen::InsensitiveStr::Ascii("uraing"), + dictgen::InsensitiveStr::Ascii("uter"), + dictgen::InsensitiveStr::Ascii("utered"), + dictgen::InsensitiveStr::Ascii("uters"), + dictgen::InsensitiveStr::Ascii("utner"), dictgen::InsensitiveStr::Ascii("utnered"), dictgen::InsensitiveStr::Ascii("utners"), + dictgen::InsensitiveStr::Ascii("uttering"), ], values: &[ + &["encode"], + &["encoded"], + &["encoder"], + &["encoders"], + &["encodes"], + &["encoding"], + &["encodings"], &["enclosed"], &["enclosure"], &["encompasses"], @@ -61505,18 +115592,45 @@ pub static WORD_ENCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["encompasses"], &["encompasses"], &["encompasses"], + &["encode"], + &["encoded"], + &["encoder"], + &["encoders"], + &["encodes"], + &["encoding"], + &["encodings"], + &["encode", "encore"], + &["encoded"], + &["encoder"], + &["encoders"], + &["encodes", "encores"], + &["encoding"], + &["encodings"], &["incorporated"], &["incorporating"], - &["encountered"], + &["enclose", "encode"], + &["enclosed", "encoded"], + &["encoder"], + &["encoders"], + &["encloses", "encodes"], + &["enclosing", "encoding"], + &["enclosings", "encodings"], + &["enclosure"], + &["encountered", "encounter"], &["encountered"], &["encounters"], &["encountered"], &["encouraging"], &["encouraging"], + &["encounter"], &["encountered"], &["encounters"], + &["encounter"], + &["encountered"], + &["encounters"], + &["encountering"], ], - range: 4..=9, + range: 2..=9, }; static WORD_ENCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61526,12 +115640,26 @@ static WORD_ENCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["enclosure"], &["enclosure"], &["encyclopedia"]], - range: 5..=8, + values: &[ + &["enclosing"], + &["enclosure"], + &["enclosing"], + &["enclosure"], + &["enclosure"], + &["include"], + &["including"], + &["encyclopedia"], + ], + range: 3..=8, }; static WORD_ENCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61553,7 +115681,9 @@ static WORD_ENCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -61572,7 +115702,9 @@ pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["enchantment"], - &["enhancement"], + &["enhanced"], + &["enhancement", "enchantment"], + &["enhancements", "enchantments"], &["enchanting"], &["enchantment"], &["enchantments"], @@ -61589,7 +115721,7 @@ pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["enchantments"], &["enchantments"], ], - range: 4..=8, + range: 4..=9, }; static WORD_ENCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61613,6 +115745,9 @@ pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("hnt"), dictgen::InsensitiveStr::Ascii("hnting"), dictgen::InsensitiveStr::Ascii("lve"), + dictgen::InsensitiveStr::Ascii("psualtes"), + dictgen::InsensitiveStr::Ascii("psulatzion"), + dictgen::InsensitiveStr::Ascii("psultion"), dictgen::InsensitiveStr::Ascii("rcerated"), dictgen::InsensitiveStr::Ascii("rceration"), ], @@ -61620,10 +115755,38 @@ pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["enchant"], &["enchanting"], &["enclave"], + &["encapsulates"], + &["encapsulation"], + &["encapsulation"], &["incarcerated"], &["incarceration"], ], - range: 3..=9, + 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("ale"), + dictgen::InsensitiveStr::Ascii("aled"), + dictgen::InsensitiveStr::Ascii("ales"), + dictgen::InsensitiveStr::Ascii("aling"), + dictgen::InsensitiveStr::Ascii("edding"), + dictgen::InsensitiveStr::Ascii("le"), + ], + values: &[ + &["enable"], + &["enabled"], + &["enables"], + &["enabling"], + &["embedding"], + &["enable"], + ], + range: 2..=6, }; static WORD_ENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61633,12 +115796,40 @@ static WORD_ENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("be"), + dictgen::InsensitiveStr::Ascii("bel"), + dictgen::InsensitiveStr::Ascii("beled"), + dictgen::InsensitiveStr::Ascii("beling"), + 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: &[&["enhances"], &["enhancing"], &["enameled"]], - range: 4..=6, + values: &[ + &["enable"], + &["enable"], + &["enabled"], + &["enabling"], + &["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 { @@ -61658,7 +115849,7 @@ static WORD_EM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_EMI_NODE), None, None, - None, + Some(&WORD_EML_NODE), Some(&WORD_EMM_NODE), Some(&WORD_EMN_NODE), Some(&WORD_EMO_NODE), @@ -61684,9 +115875,16 @@ pub static WORD_EMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("altion"), dictgen::InsensitiveStr::Ascii("latin"), + dictgen::InsensitiveStr::Ascii("ltor"), + dictgen::InsensitiveStr::Ascii("ltors"), ], - values: &[&["emulation"], &["emulation"]], - range: 5..=6, + values: &[ + &["emulation"], + &["emulation"], + &["emulator"], + &["emulators"], + ], + range: 4..=6, }; static WORD_EMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61696,12 +115894,24 @@ static WORD_EMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("piness"), dictgen::InsensitiveStr::Ascii("py"), + dictgen::InsensitiveStr::Ascii("y"), + dictgen::InsensitiveStr::Ascii("ying"), ], - values: &[&["emptied"], &["emptiness"], &["empty"]], - range: 2..=6, + values: &[ + &["emptied"], + &["empties"], + &["emptied"], + &["emptiness"], + &["empty"], + &["empty"], + &["emptying"], + ], + range: 1..=6, }; static WORD_EMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61757,9 +115967,14 @@ pub static WORD_EMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("loyeurs"), dictgen::InsensitiveStr::Ascii("olyees"), dictgen::InsensitiveStr::Ascii("orer"), + dictgen::InsensitiveStr::Ascii("rically"), dictgen::InsensitiveStr::Ascii("ries"), dictgen::InsensitiveStr::Ascii("risoned"), dictgen::InsensitiveStr::Ascii("risonment"), + dictgen::InsensitiveStr::Ascii("tniess"), + dictgen::InsensitiveStr::Ascii("try"), + dictgen::InsensitiveStr::Ascii("tyed"), + dictgen::InsensitiveStr::Ascii("y"), ], values: &[ &["emphasize"], @@ -61795,7 +116010,7 @@ pub static WORD_EMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["emphysema"], &["empires"], &["empirically"], - &["empirical"], + &["empirical", "imperial"], &["imperialism"], &["imperialist"], &["empirically"], @@ -61808,11 +116023,16 @@ pub static WORD_EMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["employer"], &["employees"], &["emperor"], + &["empirically"], &["empires"], &["imprisoned"], &["imprisonment"], + &["emptiness"], + &["empty"], + &["emptied"], + &["empty"], ], - range: 4..=9, + range: 1..=9, }; static WORD_EMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61825,9 +116045,15 @@ pub static WORD_EMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("bdiment"), dictgen::InsensitiveStr::Ascii("tionaly"), dictgen::InsensitiveStr::Ascii("tionella"), + dictgen::InsensitiveStr::Ascii("ty"), ], - values: &[&["embodiment"], &["emotionally"], &["emotionally"]], - range: 7..=8, + values: &[ + &["embodiment"], + &["emotionally"], + &["emotionally"], + &["empty"], + ], + range: 2..=8, }; static WORD_EMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61858,15 +116084,17 @@ pub static WORD_EMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], - &["eminent"], + &["emigrated", "immigrated"], + &["eminent", "imminent"], &["eminently"], &["emissaries"], &["emissaries"], @@ -61874,12 +116102,25 @@ pub static WORD_EMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["emissary"], &["emission"], &["emissions"], + &["emit"], &["emitted"], &["emitting"], + &["emits"], &["emitted"], &["emitting"], ], - range: 4..=8, + 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 { @@ -61889,24 +116130,30 @@ static WORD_EMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ted"), dictgen::InsensitiveStr::Ascii("ting"), dictgen::InsensitiveStr::Ascii("tion"), ], values: &[ + &["emitted"], &["emanate"], &["emanated"], &["empires"], &["emission"], + &["remiss", "amiss", "amass"], + &["amassed", "amiss"], &["emitted"], &["emitting"], - &["emission"], + &["emission", "emotion"], ], - range: 3..=5, + range: 2..=5, }; static WORD_EME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61916,6 +116163,10 @@ static WORD_EME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("rgancies"), dictgen::InsensitiveStr::Ascii("rgencias"), dictgen::InsensitiveStr::Ascii("rgend"), @@ -61924,6 +116175,10 @@ pub static WORD_EME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rgerd"), ], values: &[ + &["embedded"], + &["emergency"], + &["element"], + &["elements"], &["emergencies"], &["emergencies"], &["emerged"], @@ -61931,7 +116186,7 @@ pub static WORD_EME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["emergencies"], &["emerged"], ], - range: 5..=8, + range: 3..=8, }; static WORD_EMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -61945,6 +116200,7 @@ pub static WORD_EMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("arasaing"), dictgen::InsensitiveStr::Ascii("arass"), dictgen::InsensitiveStr::Ascii("arassed"), + dictgen::InsensitiveStr::Ascii("arasses"), dictgen::InsensitiveStr::Ascii("arassig"), dictgen::InsensitiveStr::Ascii("arassign"), dictgen::InsensitiveStr::Ascii("arassimg"), @@ -61958,6 +116214,7 @@ pub static WORD_EMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("arrasement"), dictgen::InsensitiveStr::Ascii("arrases"), dictgen::InsensitiveStr::Ascii("arrasing"), + dictgen::InsensitiveStr::Ascii("arrasingly"), dictgen::InsensitiveStr::Ascii("arrasment"), dictgen::InsensitiveStr::Ascii("arrasments"), dictgen::InsensitiveStr::Ascii("arress"), @@ -61969,12 +116226,23 @@ pub static WORD_EMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("assay"), dictgen::InsensitiveStr::Ascii("assey"), dictgen::InsensitiveStr::Ascii("asssy"), + dictgen::InsensitiveStr::Ascii("bedded"), + dictgen::InsensitiveStr::Ascii("beded"), + dictgen::InsensitiveStr::Ascii("dder"), + dictgen::InsensitiveStr::Ascii("dedded"), + dictgen::InsensitiveStr::Ascii("ebbed"), + dictgen::InsensitiveStr::Ascii("edd"), + dictgen::InsensitiveStr::Ascii("eddded"), + dictgen::InsensitiveStr::Ascii("eddeding"), + dictgen::InsensitiveStr::Ascii("edds"), dictgen::InsensitiveStr::Ascii("eded"), + dictgen::InsensitiveStr::Ascii("eed"), dictgen::InsensitiveStr::Ascii("errassing"), dictgen::InsensitiveStr::Ascii("errassment"), dictgen::InsensitiveStr::Ascii("ezelled"), dictgen::InsensitiveStr::Ascii("lamatic"), dictgen::InsensitiveStr::Ascii("odyment"), + dictgen::InsensitiveStr::Ascii("old"), dictgen::InsensitiveStr::Ascii("rago"), ], values: &[ @@ -61982,6 +116250,7 @@ pub static WORD_EMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["embarrassing"], &["embarrass"], &["embarrassed"], + &["embarrasses"], &["embarrassing"], &["embarrassing"], &["embarrassing"], @@ -61995,6 +116264,7 @@ pub static WORD_EMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["embarrassment"], &["embarrassed"], &["embarrassing"], + &["embarrassingly"], &["embarrassment"], &["embarrassment"], &["embarrassed"], @@ -62007,14 +116277,25 @@ pub static WORD_EMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["embassy"], &["embassy"], &["embedded"], + &["embedded"], + &["embedder"], + &["embedded"], + &["embedded"], + &["embed"], + &["embedded"], + &["embedding"], + &["embeds"], + &["embedded"], + &["embed"], &["embarrassing"], &["embarrassment"], &["embezzled"], &["emblematic"], &["embodiment"], + &["embolden"], &["embargo"], ], - range: 4..=10, + range: 3..=10, }; static WORD_EMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62024,22 +116305,28 @@ static WORD_EMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_EMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("baroged"), + dictgen::InsensitiveStr::Ascii("ble"), dictgen::InsensitiveStr::Ascii("brassing"), dictgen::InsensitiveStr::Ascii("brgo"), dictgen::InsensitiveStr::Ascii("bssy"), + dictgen::InsensitiveStr::Ascii("illing"), dictgen::InsensitiveStr::Ascii("pthetic"), dictgen::InsensitiveStr::Ascii("pthize"), dictgen::InsensitiveStr::Ascii("pthy"), ], values: &[ + &["embargoed"], + &["enable"], &["embarrassing"], &["embargo"], &["embassy"], + &["emailing"], &["empathetic"], &["empathize"], &["empathy"], ], - range: 4..=8, + range: 3..=8, }; static WORD_EL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62054,13 +116341,13 @@ static WORD_EL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_ELD_NODE), Some(&WORD_ELE_NODE), None, - None, + Some(&WORD_ELG_NODE), None, Some(&WORD_ELI_NODE), None, None, Some(&WORD_ELL_NODE), - None, + Some(&WORD_ELM_NODE), None, Some(&WORD_ELO_NODE), Some(&WORD_ELP_NODE), @@ -62082,9 +116369,29 @@ static WORD_ELS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ELS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ehwere")], - values: &[&["elsewhere"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("ef"), + dictgen::InsensitiveStr::Ascii("ehwere"), + dictgen::InsensitiveStr::Ascii("eof"), + dictgen::InsensitiveStr::Ascii("eswhere"), + 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"], + &["elseif"], + &["elseif"], + ], + range: 2..=7, }; static WORD_ELP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62121,6 +116428,35 @@ pub static WORD_ELO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -62128,32 +116464,46 @@ static WORD_ELL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ELL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("apsed"), dictgen::InsensitiveStr::Ascii("ected"), 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"], &["ellington"], + &["eliminate"], + &["eliminated"], + &["eliminates"], + &["eliminating"], &["ellington"], &["elliptical"], &["elliptical"], &["elliptical"], + &["ellipsis"], &["elliptical"], + &["elision"], &["elliott"], &["elliptical"], &["elliott"], &["elliptical"], ], - range: 4..=8, + range: 4..=9, }; static WORD_ELI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62169,6 +116519,7 @@ pub static WORD_ELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("manation"), dictgen::InsensitiveStr::Ascii("menates"), dictgen::InsensitiveStr::Ascii("mentary"), + dictgen::InsensitiveStr::Ascii("miante"), dictgen::InsensitiveStr::Ascii("miate"), dictgen::InsensitiveStr::Ascii("mimates"), dictgen::InsensitiveStr::Ascii("minacion"), @@ -62178,8 +116529,19 @@ pub static WORD_ELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], @@ -62191,6 +116553,7 @@ pub static WORD_ELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["eliminates"], &["elementary"], &["eliminate"], + &["eliminate"], &["eliminates"], &["elimination"], &["eliminates"], @@ -62199,12 +116562,34 @@ pub static WORD_ELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["elimination"], &["elimination"], &["elimination"], + &["elimination"], &["eliminates"], + &["eliminate"], &["eliminates"], + &["eliminate"], + &["eliminated"], + &["ellipse", "eclipse"], + &["ellipses", "eclipses", "ellipsis"], + &["ellipsis", "eclipses"], + &["ellipses", "ellipsis"], + &["elliptic"], + &["elliptical"], + &["ellipticity"], &["elitism"], &["elitism"], ], - range: 5..=8, + 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 { @@ -62213,20 +116598,20 @@ static WORD_ELE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_ELE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_ELEA_NODE), None, Some(&WORD_ELEC_NODE), None, + Some(&WORD_ELEE_NODE), None, - None, - None, + Some(&WORD_ELEG_NODE), None, None, None, Some(&WORD_ELEK_NODE), None, Some(&WORD_ELEM_NODE), - None, + Some(&WORD_ELEN_NODE), None, Some(&WORD_ELEP_NODE), None, @@ -62258,14 +116643,18 @@ static WORD_ELET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_ELET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ricity")], - values: &[&["electricity"]], - range: 6..=6, + 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"]), + value: Some(&["eels", "else"]), }; pub static WORD_ELES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -62299,6 +116688,17 @@ pub static WORD_ELEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -62306,26 +116706,76 @@ static WORD_ELEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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("nts"), + dictgen::InsensitiveStr::Ascii("tary"), ], values: &[ + &["element"], + &["elementary"], + &["element"], + &["elements"], + &["element"], + &["element"], + &["element"], + &["elemental"], + &["elements"], + &["element"], + &["elements"], + &["elements"], + &["elements"], + &["elementary"], + &["element", "elements"], &["elementary"], &["elementary"], &["elementary"], &["elementary"], &["elementary"], - &["elementary"], + &["element"], + &["elemental"], + &["element"], + &["elements"], + &["elements"], + &["eliminate"], &["eliminated"], + &["eliminates"], &["eliminating"], + &["elements"], + &["element"], + &["elements"], + &["elementary"], ], - range: 4..=7, + range: 2..=7, }; static WORD_ELEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62339,6 +116789,31 @@ pub static WORD_ELEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -62374,82 +116849,173 @@ static WORD_ELEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str ]; static WORD_ELECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ELECT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ELECT_CHILDREN), value: None, }; -pub static WORD_ELECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("hor"), - dictgen::InsensitiveStr::Ascii("ic"), - dictgen::InsensitiveStr::Ascii("ircal"), - dictgen::InsensitiveStr::Ascii("ivite"), - dictgen::InsensitiveStr::Ascii("ivre"), - dictgen::InsensitiveStr::Ascii("on"), - dictgen::InsensitiveStr::Ascii("oraat"), - dictgen::InsensitiveStr::Ascii("orale"), - dictgen::InsensitiveStr::Ascii("oratul"), - dictgen::InsensitiveStr::Ascii("orite"), - dictgen::InsensitiveStr::Ascii("orlytes"), - dictgen::InsensitiveStr::Ascii("ormagnetic"), - dictgen::InsensitiveStr::Ascii("orn"), - dictgen::InsensitiveStr::Ascii("ornic"), - dictgen::InsensitiveStr::Ascii("ornics"), - dictgen::InsensitiveStr::Ascii("orns"), - dictgen::InsensitiveStr::Ascii("rial"), - dictgen::InsensitiveStr::Ascii("ricain"), - dictgen::InsensitiveStr::Ascii("rican"), - dictgen::InsensitiveStr::Ascii("ricial"), - dictgen::InsensitiveStr::Ascii("ricien"), - dictgen::InsensitiveStr::Ascii("ricion"), - dictgen::InsensitiveStr::Ascii("riciy"), - dictgen::InsensitiveStr::Ascii("ricman"), - dictgen::InsensitiveStr::Ascii("ricrain"), - dictgen::InsensitiveStr::Ascii("rictian"), - dictgen::InsensitiveStr::Ascii("ricty"), - dictgen::InsensitiveStr::Ascii("ricy"), - dictgen::InsensitiveStr::Ascii("rinic"), - dictgen::InsensitiveStr::Ascii("risity"), - dictgen::InsensitiveStr::Ascii("ritian"), - dictgen::InsensitiveStr::Ascii("roal"), - dictgen::InsensitiveStr::Ascii("roate"), - dictgen::InsensitiveStr::Ascii("robytes"), - dictgen::InsensitiveStr::Ascii("rocity"), - dictgen::InsensitiveStr::Ascii("rocytes"), - dictgen::InsensitiveStr::Ascii("rodan"), - dictgen::InsensitiveStr::Ascii("roinc"), - dictgen::InsensitiveStr::Ascii("rolites"), - dictgen::InsensitiveStr::Ascii("roltyes"), - dictgen::InsensitiveStr::Ascii("rolye"), - dictgen::InsensitiveStr::Ascii("rolyes"), - dictgen::InsensitiveStr::Ascii("rolyts"), - dictgen::InsensitiveStr::Ascii("romagentic"), - dictgen::InsensitiveStr::Ascii("romagnatic"), - dictgen::InsensitiveStr::Ascii("romagnectic"), - dictgen::InsensitiveStr::Ascii("romagnetc"), - dictgen::InsensitiveStr::Ascii("romagntic"), - dictgen::InsensitiveStr::Ascii("roman"), - dictgen::InsensitiveStr::Ascii("romangetic"), - dictgen::InsensitiveStr::Ascii("romegnetic"), - dictgen::InsensitiveStr::Ascii("ronagnetic"), - dictgen::InsensitiveStr::Ascii("roncis"), - dictgen::InsensitiveStr::Ascii("roncs"), - dictgen::InsensitiveStr::Ascii("rones"), - dictgen::InsensitiveStr::Ascii("ronicas"), - dictgen::InsensitiveStr::Ascii("ronicos"), - dictgen::InsensitiveStr::Ascii("ronik"), - dictgen::InsensitiveStr::Ascii("ronis"), - dictgen::InsensitiveStr::Ascii("ronix"), - dictgen::InsensitiveStr::Ascii("roylte"), - dictgen::InsensitiveStr::Ascii("royltes"), + 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: &[ - &["electro"], - &["electric"], &["electrical"], - &["elective"], - &["elective"], + &["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("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"], @@ -62460,54 +117026,44 @@ pub static WORD_ELECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["electronic"], &["electronics"], &["electrons"], - &["electrical"], - &["electrician"], - &["electrician"], - &["electrical"], - &["electrician"], - &["electrician"], - &["electricity"], - &["electrician"], - &["electrician"], - &["electrician"], - &["electricity"], - &["electricity"], - &["electrician"], - &["electricity"], - &["electrician"], - &["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..=11, + 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 { @@ -62524,6 +117080,17 @@ pub static WORD_ELECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("te")], + values: &[&["relate"]], + range: 2..=2, +}; + static WORD_ELD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ELD_CHILDREN), value: None, @@ -62544,9 +117111,10 @@ pub static WORD_ELC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("ipse"), dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tromagnetic"), ], - values: &[&["eclipse"], &["election"]], - range: 4..=4, + values: &[&["eclipse"], &["election"], &["electromagnetic"]], + range: 4..=11, }; static WORD_ELA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62601,23 +117169,33 @@ pub static WORD_EI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("nfahc"), + dictgen::InsensitiveStr::Ascii("nstance"), + dictgen::InsensitiveStr::Ascii("sntance"), dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("th"), dictgen::InsensitiveStr::Ascii("tquette"), ], values: &[ &["einfach"], &["eighteen"], &["eighteen"], - &["eighth"], - &["eighteen"], - &["einfach"], &["either"], + &["eighth", "eight"], + &["eighteen"], + &["either"], + &["einfach"], + &["instance"], + &["instance"], + &["either"], + &["with"], &["etiquette"], ], - range: 3..=7, + range: 2..=7, }; static WORD_EH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62627,24 +117205,44 @@ static WORD_EH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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: 5..=9, + range: 1..=9, }; static WORD_EG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62658,6 +117256,17 @@ pub static WORD_EG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("alitara"), dictgen::InsensitiveStr::Ascii("alitatian"), dictgen::InsensitiveStr::Ascii("aliterian"), + 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"), @@ -62677,6 +117286,17 @@ pub static WORD_EG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["egalitarian"], &["egalitarian"], &["egalitarian"], + &["edge"], + &["edges"], + &["edge"], + &["general"], + &["generalise"], + &["generalised"], + &["generalises"], + &["generalize"], + &["generalized"], + &["generalizes"], + &["generally"], &["egotistical"], &["egotistical"], &["egotistical"], @@ -62691,7 +117311,7 @@ pub static WORD_EG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["egyptian"], &["egyptians"], ], - range: 6..=9, + range: 1..=9, }; static WORD_EF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62701,20 +117321,39 @@ static WORD_EF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_EF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ect"), + dictgen::InsensitiveStr::Ascii("ective"), + dictgen::InsensitiveStr::Ascii("ectively"), dictgen::InsensitiveStr::Ascii("el"), + dictgen::InsensitiveStr::Ascii("erences"), + dictgen::InsensitiveStr::Ascii("etivity"), + dictgen::InsensitiveStr::Ascii("fctive"), + dictgen::InsensitiveStr::Ascii("fctively"), dictgen::InsensitiveStr::Ascii("feciency"), dictgen::InsensitiveStr::Ascii("fecient"), dictgen::InsensitiveStr::Ascii("feciently"), dictgen::InsensitiveStr::Ascii("fecitvely"), + dictgen::InsensitiveStr::Ascii("feck"), + dictgen::InsensitiveStr::Ascii("fecked"), + dictgen::InsensitiveStr::Ascii("fecks"), + dictgen::InsensitiveStr::Ascii("feckt"), + dictgen::InsensitiveStr::Ascii("fectice"), + dictgen::InsensitiveStr::Ascii("fecticely"), dictgen::InsensitiveStr::Ascii("fectionate"), dictgen::InsensitiveStr::Ascii("fectivelly"), dictgen::InsensitiveStr::Ascii("fectivenss"), dictgen::InsensitiveStr::Ascii("fectiviness"), dictgen::InsensitiveStr::Ascii("fectivley"), dictgen::InsensitiveStr::Ascii("fectivly"), + dictgen::InsensitiveStr::Ascii("fectivness"), + dictgen::InsensitiveStr::Ascii("fectly"), + dictgen::InsensitiveStr::Ascii("fekt"), + dictgen::InsensitiveStr::Ascii("fexts"), + dictgen::InsensitiveStr::Ascii("ficcient"), dictgen::InsensitiveStr::Ascii("ficeincy"), dictgen::InsensitiveStr::Ascii("ficeint"), dictgen::InsensitiveStr::Ascii("ficeintly"), + dictgen::InsensitiveStr::Ascii("ficencty"), dictgen::InsensitiveStr::Ascii("ficency"), dictgen::InsensitiveStr::Ascii("ficent"), dictgen::InsensitiveStr::Ascii("ficently"), @@ -62726,6 +117365,9 @@ pub static WORD_EF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ficienty"), dictgen::InsensitiveStr::Ascii("ficieny"), dictgen::InsensitiveStr::Ascii("fictiveness"), + dictgen::InsensitiveStr::Ascii("fiency"), + dictgen::InsensitiveStr::Ascii("fient"), + dictgen::InsensitiveStr::Ascii("fiently"), dictgen::InsensitiveStr::Ascii("ford"), dictgen::InsensitiveStr::Ascii("fordlessly"), dictgen::InsensitiveStr::Ascii("fords"), @@ -62734,41 +117376,65 @@ pub static WORD_EF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("fortlessley"), dictgen::InsensitiveStr::Ascii("fortlessy"), dictgen::InsensitiveStr::Ascii("fulence"), + dictgen::InsensitiveStr::Ascii("orceable"), ], values: &[ + &["effect"], + &["effective"], + &["effectively"], &["evil"], + &["references"], + &["effectivity"], + &["effective"], + &["effectively"], &["efficiency"], &["efficient"], &["efficiently"], &["effectively"], + &["effect"], + &["effected"], + &["effects"], + &["effect"], + &["effective"], + &["effectively"], &["affectionate"], &["effectively"], &["effectiveness"], &["effectiveness"], &["effectively"], &["effectively"], - &["efficiency"], - &["efficient"], - &["efficiently"], - &["efficiency"], - &["efficient"], - &["efficiently"], - &["efficiency"], - &["efficiently"], - &["efficient"], - &["efficiency"], - &["efficiently"], - &["efficiently"], - &["efficiency"], &["effectiveness"], - &["effort"], + &["effectively"], + &["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"], + &["efforts", "affords"], &["effortlessly"], &["effortlessly"], &["effortlessly"], &["effortlessly"], &["effluence"], + &["enforceable"], ], range: 2..=11, }; @@ -62779,9 +117445,33 @@ static WORD_EE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_EE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("arly")], - values: &[&["early"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("arly"), + dictgen::InsensitiveStr::Ascii("eprom"), + 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"], + &["description"], + &["every"], + &["everything"], + &["everywhere"], + &["extract"], + &["extracted"], + &["extracting"], + &["extraction"], + &["extracts"], + ], + range: 4..=9, }; static WORD_ED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62792,25 +117482,59 @@ static WORD_ED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_ED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("biles"), + dictgen::InsensitiveStr::Ascii("cdic"), + dictgen::InsensitiveStr::Ascii("ditable"), + dictgen::InsensitiveStr::Ascii("e"), dictgen::InsensitiveStr::Ascii("ficient"), + dictgen::InsensitiveStr::Ascii("iable"), dictgen::InsensitiveStr::Ascii("ibels"), + dictgen::InsensitiveStr::Ascii("ige"), + dictgen::InsensitiveStr::Ascii("iges"), + dictgen::InsensitiveStr::Ascii("itedt"), + dictgen::InsensitiveStr::Ascii("itiing"), dictgen::InsensitiveStr::Ascii("itoras"), dictgen::InsensitiveStr::Ascii("itores"), + dictgen::InsensitiveStr::Ascii("itoro"), + 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("oema"), dictgen::InsensitiveStr::Ascii("ucacional"), dictgen::InsensitiveStr::Ascii("ucationnal"), + dictgen::InsensitiveStr::Ascii("xpected"), ], values: &[ &["edibles"], + &["ebcdic"], + &["editable"], + &["edge"], &["deficient"], + &["editable"], &["edibles"], + &["edge"], + &["edges"], + &["edited"], + &["editing"], &["editors"], &["editors"], + &["editor"], + &["edit"], + &["edited"], + &["editor"], + &["editing"], + &["editor"], + &["end"], + &["endif"], &["edema"], &["educational"], &["educational"], + &["expected"], ], - range: 4..=10, + range: 1..=10, }; static WORD_EC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62820,13 +117544,19 @@ static WORD_EC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("ognized"), dictgen::InsensitiveStr::Ascii("oligical"), dictgen::InsensitiveStr::Ascii("ologia"), dictgen::InsensitiveStr::Ascii("omonic"), @@ -62845,21 +117575,37 @@ pub static WORD_EC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("onomisit"), dictgen::InsensitiveStr::Ascii("onomisiti"), dictgen::InsensitiveStr::Ascii("onomistes"), + 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"), ], values: &[ + &["excessive"], &["eclectic"], &["economy"], + &["except"], + &["exception"], + &["exceptions"], &["deciduous"], &["eclipse"], &["eclipse"], &["eclipse"], &["eclipse"], + &["eclipse"], + &["recognized"], &["ecological"], &["ecological"], &["economic"], @@ -62878,12 +117624,22 @@ pub static WORD_EC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["economists"], &["economist"], &["economists"], + &["explicit"], + &["explicitly"], + &["secret", "erect"], + &["especially"], &["ecstasy"], &["ecstasy"], &["ecstasy"], &["etc"], &["ecstatic"], &["ecstasy"], + &["except"], + &["excite"], + &["excited"], + &["excites"], + &["exciting"], + &["extracted"], ], range: 1..=10, }; @@ -62894,9 +117650,21 @@ static WORD_EB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_EB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("cuase")], - values: &[&["becuase"]], - range: 5..=5, + 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"], + &["becuase"], + &["embedded"], + ], + range: 3..=5, }; static WORD_EA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -62906,17 +117674,36 @@ static WORD_EA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_EA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("bled"), + dictgen::InsensitiveStr::Ascii("cf"), + dictgen::InsensitiveStr::Ascii("cg"), dictgen::InsensitiveStr::Ascii("chohter"), dictgen::InsensitiveStr::Ascii("chotehr"), + dictgen::InsensitiveStr::Ascii("chs"), dictgen::InsensitiveStr::Ascii("chtoher"), + dictgen::InsensitiveStr::Ascii("ctly"), + dictgen::InsensitiveStr::Ascii("grely"), dictgen::InsensitiveStr::Ascii("hc"), + dictgen::InsensitiveStr::Ascii("ilier"), + dictgen::InsensitiveStr::Ascii("iser"), dictgen::InsensitiveStr::Ascii("lier"), + dictgen::InsensitiveStr::Ascii("liest"), + dictgen::InsensitiveStr::Ascii("mple"), + dictgen::InsensitiveStr::Ascii("mples"), + dictgen::InsensitiveStr::Ascii("nable"), + dictgen::InsensitiveStr::Ascii("nble"), + dictgen::InsensitiveStr::Ascii("rch"), dictgen::InsensitiveStr::Ascii("rhtbound"), dictgen::InsensitiveStr::Ascii("rhtquakes"), dictgen::InsensitiveStr::Ascii("rilest"), + dictgen::InsensitiveStr::Ascii("rler"), + dictgen::InsensitiveStr::Ascii("rliear"), dictgen::InsensitiveStr::Ascii("rlies"), dictgen::InsensitiveStr::Ascii("rliet"), + dictgen::InsensitiveStr::Ascii("rlist"), + dictgen::InsensitiveStr::Ascii("rlyer"), dictgen::InsensitiveStr::Ascii("rnt"), + dictgen::InsensitiveStr::Ascii("rpeice"), dictgen::InsensitiveStr::Ascii("rpluggs"), dictgen::InsensitiveStr::Ascii("rplus"), dictgen::InsensitiveStr::Ascii("rthboud"), @@ -62929,25 +117716,54 @@ pub static WORD_EA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("rthquaks"), dictgen::InsensitiveStr::Ascii("rthquate"), dictgen::InsensitiveStr::Ascii("rthqukes"), + dictgen::InsensitiveStr::Ascii("sely"), + dictgen::InsensitiveStr::Ascii("ser"), + dictgen::InsensitiveStr::Ascii("sili"), + dictgen::InsensitiveStr::Ascii("siliy"), + dictgen::InsensitiveStr::Ascii("silly"), + dictgen::InsensitiveStr::Ascii("siy"), + dictgen::InsensitiveStr::Ascii("sly"), dictgen::InsensitiveStr::Ascii("sthetically"), dictgen::InsensitiveStr::Ascii("sthetics"), dictgen::InsensitiveStr::Ascii("stwod"), dictgen::InsensitiveStr::Ascii("stwoood"), dictgen::InsensitiveStr::Ascii("stwoord"), + dictgen::InsensitiveStr::Ascii("syer"), dictgen::InsensitiveStr::Ascii("tswood"), + dictgen::InsensitiveStr::Ascii("turn"), + dictgen::InsensitiveStr::Ascii("xct"), ], values: &[ - &["eachother"], + &["enabled"], + &["each"], + &["each"], &["eachother"], &["eachother"], &["each"], + &["eachother"], + &["exactly"], + &["eagerly"], + &["each"], &["earlier"], + &["easier"], + &["earlier"], + &["earliest"], + &["example"], + &["examples"], + &["enable"], + &["enable"], + &["search", "each"], &["earthbound"], &["earthquakes"], &["earliest"], + &["earlier"], + &["earlier"], &["earliest"], &["earliest"], + &["earliest"], + &["earlier"], &["earned"], + &["earpiece"], &["earplugs"], &["earplugs"], &["earthbound"], @@ -62960,12 +117776,22 @@ pub static WORD_EA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["earthquakes"], &["earthquake"], &["earthquakes"], + &["easily"], + &["easier", "eraser"], + &["easily"], + &["easily"], + &["easily"], + &["easily"], + &["easily"], &["esthetically"], &["esthetics"], &["eastwood"], &["eastwood"], &["eastwood"], + &["easier"], &["eastwood"], + &["return", "saturn"], + &["exact"], ], range: 2..=11, }; @@ -62978,24 +117804,24 @@ static WORD_D_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_D_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_DA_NODE), None, - None, + Some(&WORD_DC_NODE), Some(&WORD_DD_NODE), Some(&WORD_DE_NODE), - None, - None, + Some(&WORD_DF_NODE), + Some(&WORD_DG_NODE), None, Some(&WORD_DI_NODE), None, None, + Some(&WORD_DL_NODE), None, - None, - None, + Some(&WORD_DN_NODE), Some(&WORD_DO_NODE), - None, + Some(&WORD_DP_NODE), None, Some(&WORD_DR_NODE), Some(&WORD_DS_NODE), - None, + Some(&WORD_DT_NODE), Some(&WORD_DU_NODE), None, Some(&WORD_DW_NODE), @@ -63012,23 +117838,38 @@ static WORD_DY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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"), @@ -63056,22 +117897,37 @@ pub static WORD_DY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg values: &[ &["dynamically"], &["dynamically"], + &["dynamic"], + &["dynamically"], &["dynamics"], &["dynamite"], &["dynasty"], &["dryas"], &["dynamically"], + &["dynamically"], &["dynamics"], &["dynamite"], + &["dynamic"], + &["dynamincally"], + &["dynamics"], &["dynamically"], &["dynamically"], &["dynamics"], &["dynamically"], + &["dynamically"], &["dynamics"], &["dynamics"], &["dynamics"], &["dynamite"], + &["dynamic"], + &["dynamically"], &["dynasty"], + &["dynamically"], + &["dynamic"], + &["dynamically"], + &["dynamic"], + &["dynamically"], + &["dynamics"], &["dynasty"], &["dysphoria"], &["deregulation"], @@ -63111,98 +117967,388 @@ pub static WORD_DW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg }; static WORD_DU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DU_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DU_CHILDREN), value: None, }; -pub static WORD_DU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_DU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_DUA_NODE), + Some(&WORD_DUB_NODE), + Some(&WORD_DUC_NODE), + None, + Some(&WORD_DUE_NODE), + None, + None, + None, + None, + 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("aghter"), - dictgen::InsensitiveStr::Ascii("aghters"), - dictgen::InsensitiveStr::Ascii("ailty"), - dictgen::InsensitiveStr::Ascii("altiy"), - dictgen::InsensitiveStr::Ascii("blications"), - dictgen::InsensitiveStr::Ascii("bsetp"), - dictgen::InsensitiveStr::Ascii("etschland"), - dictgen::InsensitiveStr::Ascii("laity"), - dictgen::InsensitiveStr::Ascii("leing"), - dictgen::InsensitiveStr::Ascii("mbbellls"), - dictgen::InsensitiveStr::Ascii("mbbels"), - dictgen::InsensitiveStr::Ascii("mbfouded"), - dictgen::InsensitiveStr::Ascii("mbfoundeads"), - dictgen::InsensitiveStr::Ascii("mbfouned"), - dictgen::InsensitiveStr::Ascii("mptser"), - dictgen::InsensitiveStr::Ascii("mspter"), - dictgen::InsensitiveStr::Ascii("negon"), - dictgen::InsensitiveStr::Ascii("negons"), - dictgen::InsensitiveStr::Ascii("ngeoness"), - dictgen::InsensitiveStr::Ascii("ngeos"), - dictgen::InsensitiveStr::Ascii("ngeoun"), - dictgen::InsensitiveStr::Ascii("ngoen"), - dictgen::InsensitiveStr::Ascii("ngoens"), - dictgen::InsensitiveStr::Ascii("picate"), - dictgen::InsensitiveStr::Ascii("pilcates"), - dictgen::InsensitiveStr::Ascii("plicants"), - dictgen::InsensitiveStr::Ascii("plicas"), - dictgen::InsensitiveStr::Ascii("plicatas"), - dictgen::InsensitiveStr::Ascii("plicats"), - dictgen::InsensitiveStr::Ascii("plicitas"), - dictgen::InsensitiveStr::Ascii("plifaces"), - dictgen::InsensitiveStr::Ascii("rabiliy"), - dictgen::InsensitiveStr::Ascii("rabillity"), - dictgen::InsensitiveStr::Ascii("rabiltiy"), - dictgen::InsensitiveStr::Ascii("rig"), - dictgen::InsensitiveStr::Ascii("rring"), - dictgen::InsensitiveStr::Ascii("sbtep"), - dictgen::InsensitiveStr::Ascii("sfunctional"), - dictgen::InsensitiveStr::Ascii("sgustingly"), - dictgen::InsensitiveStr::Ascii("stification"), - dictgen::InsensitiveStr::Ascii("ting"), + dictgen::InsensitiveStr::Ascii("btep"), + dictgen::InsensitiveStr::Ascii("functional"), + dictgen::InsensitiveStr::Ascii("gustingly"), + dictgen::InsensitiveStr::Ascii("tification"), ], values: &[ - &["daughter"], - &["daughters"], - &["duality"], - &["duality"], - &["publications"], - &["dubstep"], - &["deutschland"], - &["duality"], - &["dueling"], - &["dumbbells"], - &["dumbbells"], - &["dumbfounded"], - &["dumbfounded"], - &["dumbfounded"], - &["dumpster"], - &["dumpster"], - &["dungeon"], - &["dungeons"], - &["dungeons"], - &["dungeons"], - &["dungeon"], - &["dungeon"], - &["dungeons"], - &["duplicate"], - &["duplicates"], - &["duplicates"], - &["duplicates"], - &["duplicates"], - &["duplicates"], - &["duplicates"], - &["duplicates"], - &["durability"], - &["durability"], - &["durability"], - &["during"], - &["during"], &["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: 3..=11, + 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("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("lifaces"), + 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"], + &["duplicates"], + &["duplicate"], + &["duplicate"], + &["duplicated"], + &["duplicates"], + &["duplicate"], + &["duplicate"], + &["duplicated"], + &["duplicates"], + &["duplicating"], + &["duplication"], + &["duplications"], + &["duplicates"], + &["duplicates"], + &["duplicate"], + &["duplicates"], + &["duplicated"], + &["duplicates"], + &["duplicates"], + &["duplicates"], + &["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_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_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("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("setp"), + ], + values: &[ + &["dubious"], + &["duplicate"], + &["duplicate"], + &["duplicate"], + &["duplicated"], + &["duplicates"], + &["duplication"], + &["publications"], + &["dubstep"], + ], + range: 3..=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 { @@ -63212,91 +118358,319 @@ static WORD_DS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("yfunction"), dictgen::InsensitiveStr::Ascii("yfunctional"), dictgen::InsensitiveStr::Ascii("yphoria"), dictgen::InsensitiveStr::Ascii("ytopian"), ], values: &[ + &["discrete"], + &["discretion"], + &["described"], + &["disable"], + &["disabled"], + &["displays"], + &["destination"], &["dysfunction"], &["dysfunctional"], &["dysphoria"], &["dystopian"], ], - range: 7..=11, + range: 5..=11, }; static WORD_DR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DR_CHILDREN), value: None, }; -pub static WORD_DR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aclua"), - dictgen::InsensitiveStr::Ascii("acual"), - dictgen::InsensitiveStr::Ascii("aculea"), - dictgen::InsensitiveStr::Ascii("aculla"), - dictgen::InsensitiveStr::Ascii("agones"), - dictgen::InsensitiveStr::Ascii("agonus"), - dictgen::InsensitiveStr::Ascii("akest"), - dictgen::InsensitiveStr::Ascii("amaticaly"), - dictgen::InsensitiveStr::Ascii("amaticlly"), - dictgen::InsensitiveStr::Ascii("ammatically"), - dictgen::InsensitiveStr::Ascii("amtic"), - dictgen::InsensitiveStr::Ascii("ankenstein"), - dictgen::InsensitiveStr::Ascii("asitcally"), - dictgen::InsensitiveStr::Ascii("asticaly"), - dictgen::InsensitiveStr::Ascii("asticlly"), - dictgen::InsensitiveStr::Ascii("aughtman"), - dictgen::InsensitiveStr::Ascii("avadian"), - dictgen::InsensitiveStr::Ascii("easm"), - dictgen::InsensitiveStr::Ascii("fiting"), - dictgen::InsensitiveStr::Ascii("ibbel"), - dictgen::InsensitiveStr::Ascii("iectly"), - dictgen::InsensitiveStr::Ascii("iectx"), - dictgen::InsensitiveStr::Ascii("ifitng"), - dictgen::InsensitiveStr::Ascii("iftig"), - dictgen::InsensitiveStr::Ascii("inkes"), - dictgen::InsensitiveStr::Ascii("iveris"), - dictgen::InsensitiveStr::Ascii("nik"), - dictgen::InsensitiveStr::Ascii("otmund"), - dictgen::InsensitiveStr::Ascii("uming"), - dictgen::InsensitiveStr::Ascii("ummless"), + 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("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"), ], values: &[ - &["dracula"], - &["dracula"], - &["dracula"], - &["dracula"], - &["dragons"], - &["dragons"], - &["darkest"], - &["dramatically"], - &["dramatically"], - &["grammatically"], - &["dramatic"], - &["frankenstein"], - &["drastically"], - &["drastically"], - &["drastically"], - &["draughtsman"], - &["dravidian"], - &["dreams"], - &["drifting"], + &["droppable"], + &["droppable"], + &["dropped"], + &["dropping"], + &["dropped"], + &["dropped"], + &["drops"], + &["dropout"], + &["dortmund"], + ], + range: 3..=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("ectly"), + dictgen::InsensitiveStr::Ascii("ectx"), + dictgen::InsensitiveStr::Ascii("fitng"), + dictgen::InsensitiveStr::Ascii("ftig"), + dictgen::InsensitiveStr::Ascii("nkes"), + dictgen::InsensitiveStr::Ascii("ty"), + dictgen::InsensitiveStr::Ascii("veing"), + dictgen::InsensitiveStr::Ascii("veris"), + dictgen::InsensitiveStr::Ascii("vr"), + ], + values: &[ + &["diagram"], + &["diagrammed"], + &["diagramming"], + &["diagrams"], &["dribble"], &["directly"], &["directx"], &["drifting"], &["drifting"], &["drinkers"], + &["dirty"], + &["driving"], &["drivers"], - &["drink"], - &["dortmund"], - &["drumming"], - &["drumless"], + &["driver"], ], - range: 3..=11, + 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("scription"), + dictgen::InsensitiveStr::Ascii("scriptions"), + ], + values: &[ + &["dreams"], + &["drawn"], + &["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 { @@ -63315,7 +118689,7 @@ static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_DOI_NODE), None, - None, + Some(&WORD_DOK_NODE), Some(&WORD_DOL_NODE), Some(&WORD_DOM_NODE), Some(&WORD_DON_NODE), @@ -63328,101 +118702,158 @@ static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_DOU_NODE), None, Some(&WORD_DOW_NODE), + Some(&WORD_DOX_NODE), + None, + None, +]; + +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, + None, + Some(&WORD_DOWS_NODE), + Some(&WORD_DOWT_NODE), + None, + None, + None, None, None, None, ]; -static WORD_DOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DOW_CHILDREN), +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_DOWN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Nested(&WORD_DOWN_CHILDREN), value: None, }; -pub static WORD_DOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_DOWN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + 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("loads"), - dictgen::InsensitiveStr::Ascii("ngarde"), - dictgen::InsensitiveStr::Ascii("ngarded"), - dictgen::InsensitiveStr::Ascii("ngrated"), - dictgen::InsensitiveStr::Ascii("nlaod"), - dictgen::InsensitiveStr::Ascii("nlaodable"), - dictgen::InsensitiveStr::Ascii("nlaoded"), - dictgen::InsensitiveStr::Ascii("nlaoding"), - dictgen::InsensitiveStr::Ascii("nlaods"), - dictgen::InsensitiveStr::Ascii("nloaad"), - dictgen::InsensitiveStr::Ascii("nloadas"), - dictgen::InsensitiveStr::Ascii("nloadbale"), - dictgen::InsensitiveStr::Ascii("nloadbel"), - dictgen::InsensitiveStr::Ascii("nloadbig"), - dictgen::InsensitiveStr::Ascii("nloadble"), - dictgen::InsensitiveStr::Ascii("nloadeble"), - dictgen::InsensitiveStr::Ascii("nloades"), - dictgen::InsensitiveStr::Ascii("nloas"), - dictgen::InsensitiveStr::Ascii("novted"), - dictgen::InsensitiveStr::Ascii("novting"), - dictgen::InsensitiveStr::Ascii("nroaded"), - dictgen::InsensitiveStr::Ascii("nsiders"), - dictgen::InsensitiveStr::Ascii("nstar"), - dictgen::InsensitiveStr::Ascii("nstaris"), - dictgen::InsensitiveStr::Ascii("nstiars"), - dictgen::InsensitiveStr::Ascii("ntokers"), - dictgen::InsensitiveStr::Ascii("ntoking"), - dictgen::InsensitiveStr::Ascii("ntraded"), - dictgen::InsensitiveStr::Ascii("nviting"), - dictgen::InsensitiveStr::Ascii("nvore"), - dictgen::InsensitiveStr::Ascii("nvotear"), - dictgen::InsensitiveStr::Ascii("nvoteas"), - dictgen::InsensitiveStr::Ascii("nvoteds"), - dictgen::InsensitiveStr::Ascii("nvoteers"), - dictgen::InsensitiveStr::Ascii("nvotees"), - dictgen::InsensitiveStr::Ascii("nvoteing"), - dictgen::InsensitiveStr::Ascii("nvoteres"), - dictgen::InsensitiveStr::Ascii("nvoteros"), - dictgen::InsensitiveStr::Ascii("nvotesd"), - dictgen::InsensitiveStr::Ascii("nvotess"), - dictgen::InsensitiveStr::Ascii("nvotest"), - dictgen::InsensitiveStr::Ascii("nvoteur"), - dictgen::InsensitiveStr::Ascii("nvoteurs"), - dictgen::InsensitiveStr::Ascii("nvoties"), - dictgen::InsensitiveStr::Ascii("nvotr"), - dictgen::InsensitiveStr::Ascii("nvotres"), - dictgen::InsensitiveStr::Ascii("nvots"), - dictgen::InsensitiveStr::Ascii("nvotted"), - dictgen::InsensitiveStr::Ascii("nvotters"), - dictgen::InsensitiveStr::Ascii("nvottes"), - dictgen::InsensitiveStr::Ascii("nvotting"), - dictgen::InsensitiveStr::Ascii("nwoters"), - dictgen::InsensitiveStr::Ascii("nwoting"), + 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: &[ - &["downloads"], - &["downgrade"], - &["downgraded"], - &["downgrade"], - &["download"], - &["downloadable"], - &["downloaded"], - &["downloading"], - &["downloads"], - &["download"], - &["downloads"], - &["downloadable"], - &["downloadable"], - &["downloading"], - &["downloadable"], - &["downloadable"], - &["downloads"], - &["downloads"], - &["downvoted"], - &["downvoting"], - &["downgraded"], - &["downsides"], - &["downstairs"], - &["downstairs"], - &["downstairs"], - &["downvoters"], - &["downvoting"], - &["downgraded"], &["downvoting"], &["downvoters"], &["downvoters"], @@ -63446,10 +118877,211 @@ pub static WORD_DOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["downvoters"], &["downvoters"], &["downvoting"], - &["downvoters"], - &["downvoting"], ], - range: 5..=9, + 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("oaded")], + values: &[&["downgraded"]], + range: 5..=5, +}; + +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("vted"), + dictgen::InsensitiveStr::Ascii("vting"), + ], + values: &[&["downvoted"], &["downvoting"]], + range: 4..=5, +}; + +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("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"], + &["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("arde"), + dictgen::InsensitiveStr::Ascii("arded"), + dictgen::InsensitiveStr::Ascii("rate"), + dictgen::InsensitiveStr::Ascii("rated"), + ], + values: &[ + &["downgrade"], + &["downgraded"], + &["downgrade"], + &["downgrade", "downgraded"], + ], + range: 4..=5, +}; + +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 { @@ -63460,35 +119092,57 @@ static WORD_DOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("cehbag"), dictgen::InsensitiveStr::Ascii("chely"), dictgen::InsensitiveStr::Ascii("cheus"), + dictgen::InsensitiveStr::Ascii("cment"), + dictgen::InsensitiveStr::Ascii("ible"), + dictgen::InsensitiveStr::Ascii("ibled"), dictgen::InsensitiveStr::Ascii("lbe"), dictgen::InsensitiveStr::Ascii("lbelift"), + dictgen::InsensitiveStr::Ascii("mentc"), + dictgen::InsensitiveStr::Ascii("t"), ], values: &[ - &["doubt"], - &["doublelift"], + &["doubt", "daub"], + &["double"], + &["double"], + &["doublelift"], + &["doubly"], + &["doubles"], &["doublelift"], &["doublelift"], &["doublelift"], &["doublelift"], &["doublelift"], + &["doubly"], &["doublelift"], + &["doublequote"], &["douchebag"], &["douchey"], &["douches"], + &["document"], + &["double"], + &["doubled"], &["double"], &["doublelift"], + &["document"], + &["doubt"], ], - range: 1..=8, + range: 1..=9, }; static WORD_DOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63497,9 +119151,12 @@ static WORD_DOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rmund")], - values: &[&["dortmund"]], - range: 5..=5, + 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 { @@ -63508,9 +119165,23 @@ static WORD_DOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sapointed")], - values: &[&["disappointed"]], - range: 9..=9, + keys: &[ + dictgen::InsensitiveStr::Ascii("en"), + dictgen::InsensitiveStr::Ascii("ens"), + dictgen::InsensitiveStr::Ascii("posing"), + dictgen::InsensitiveStr::Ascii("sapointed"), + dictgen::InsensitiveStr::Ascii("ument"), + dictgen::InsensitiveStr::Ascii("uments"), + ], + values: &[ + &["dozen", "dose", "doesn"], + &["dozens"], + &["disposing"], + &["disappointed"], + &["document"], + &["documents"], + ], + range: 2..=9, }; static WORD_DOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63520,12 +119191,30 @@ static WORD_DOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["dortmund"], &["dortmund"], &["dortmund"]], - range: 4..=5, + 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 { @@ -63550,12 +119239,20 @@ static WORD_DOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_DOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cument"), dictgen::InsensitiveStr::Ascii("mdsay"), dictgen::InsensitiveStr::Ascii("msdaily"), + dictgen::InsensitiveStr::Ascii("rjam"), dictgen::InsensitiveStr::Ascii("smday"), ], - values: &[&["doomsday"], &["doomsday"], &["doomsday"]], - range: 5..=7, + values: &[ + &["document"], + &["doomsday"], + &["doomsday"], + &["doorjamb"], + &["doomsday"], + ], + range: 4..=7, }; static WORD_DON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63565,8 +119262,13 @@ static WORD_DON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -63582,8 +119284,13 @@ pub static WORD_DON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("wvoting"), ], values: &[ + &["domain"], + &["domains"], + &["dungeon"], + &["dungeons"], &["domesticated"], &["doing"], + &["done", "don"], &["downgrade"], &["downgraded"], &["download"], @@ -63598,7 +119305,7 @@ pub static WORD_DON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["downvotes"], &["downvoting"], ], - range: 2..=9, + range: 1..=9, }; static WORD_DOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63608,12 +119315,19 @@ static WORD_DOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -63631,14 +119345,25 @@ pub static WORD_DOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], values: &[ + &["domain"], + &["domain"], + &["domains"], &["dopamine"], &["democracy"], &["democrat"], &["democrats"], + &["dimension"], + &["dimensions"], &["domesticated"], &["domesticated"], + &["domain"], + &["domains"], &["dominate"], &["dominates"], &["dominating"], @@ -63656,8 +119381,12 @@ pub static WORD_DOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["dominion"], &["dominion"], &["domesticated"], + &["demonstrate"], + &["demonstrates"], + &["demonstrating"], + &["demonstration"], ], - range: 4..=9, + range: 2..=10, }; static WORD_DOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63669,6 +119398,10 @@ pub static WORD_DOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -63676,11 +119409,44 @@ pub static WORD_DOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["dolphin"], &["dolphins"], + &["dollar"], + &["dollars"], + &["dollar"], + &["dollars"], &["dolphins"], &["dolphins"], &["dolphins"], ], - range: 4..=7, + 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"), + ], + values: &[ + &["dock"], + &["docked"], + &["docker"], + &["dockerd", "docked", "docker"], + &["docking"], + &["docker"], + &["dockerd", "docked", "docker"], + &["docks"], + ], + range: 1..=4, }; static WORD_DOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63689,9 +119455,14 @@ static WORD_DOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("gn")], - values: &[&["doing"]], - range: 2..=2, + 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 { @@ -63725,90 +119496,284 @@ static WORD_DOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ns")], - values: &[&["does"]], - range: 2..=2, + 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"], + &["does"], + &["does"], + &["doing", "does", "dosing", "dozing"], + &["does"], + ], + range: 1..=4, }; static WORD_DOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DOC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DOC_CHILDREN), value: None, }; -pub static WORD_DOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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::Flat(&WORD_DOCU_CHILDREN), + value: None, +}; + +pub static WORD_DOCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("cument"), - dictgen::InsensitiveStr::Ascii("cumented"), - dictgen::InsensitiveStr::Ascii("cuments"), - dictgen::InsensitiveStr::Ascii("rines"), - dictgen::InsensitiveStr::Ascii("rtine"), - dictgen::InsensitiveStr::Ascii("rtines"), - dictgen::InsensitiveStr::Ascii("tines"), - dictgen::InsensitiveStr::Ascii("tirne"), - dictgen::InsensitiveStr::Ascii("trins"), - dictgen::InsensitiveStr::Ascii("uhebag"), - dictgen::InsensitiveStr::Ascii("uhes"), - dictgen::InsensitiveStr::Ascii("uhey"), - dictgen::InsensitiveStr::Ascii("umantaries"), - dictgen::InsensitiveStr::Ascii("umantary"), - dictgen::InsensitiveStr::Ascii("umenation"), - dictgen::InsensitiveStr::Ascii("umenatries"), - dictgen::InsensitiveStr::Ascii("umenatry"), - dictgen::InsensitiveStr::Ascii("umentacion"), - dictgen::InsensitiveStr::Ascii("umentaion"), - dictgen::InsensitiveStr::Ascii("umentaire"), - dictgen::InsensitiveStr::Ascii("umentaires"), - dictgen::InsensitiveStr::Ascii("umentaiton"), - dictgen::InsensitiveStr::Ascii("umentare"), - dictgen::InsensitiveStr::Ascii("umentarios"), - dictgen::InsensitiveStr::Ascii("umentarse"), - dictgen::InsensitiveStr::Ascii("umentarsi"), - dictgen::InsensitiveStr::Ascii("umentaties"), - dictgen::InsensitiveStr::Ascii("umentating"), - dictgen::InsensitiveStr::Ascii("umentato"), - dictgen::InsensitiveStr::Ascii("umenteries"), - dictgen::InsensitiveStr::Ascii("umentery"), - dictgen::InsensitiveStr::Ascii("umentories"), - dictgen::InsensitiveStr::Ascii("umentory"), - dictgen::InsensitiveStr::Ascii("umentry"), + dictgen::InsensitiveStr::Ascii("ement"), + dictgen::InsensitiveStr::Ascii("ements"), + dictgen::InsensitiveStr::Ascii("emnt"), + dictgen::InsensitiveStr::Ascii("emnts"), + dictgen::InsensitiveStr::Ascii("emtn"), + dictgen::InsensitiveStr::Ascii("emtnation"), + dictgen::InsensitiveStr::Ascii("emtned"), + dictgen::InsensitiveStr::Ascii("emtning"), + dictgen::InsensitiveStr::Ascii("emtns"), + dictgen::InsensitiveStr::Ascii("ent"), + dictgen::InsensitiveStr::Ascii("entation"), + dictgen::InsensitiveStr::Ascii("hebag"), + dictgen::InsensitiveStr::Ascii("hes"), + dictgen::InsensitiveStr::Ascii("hey"), + dictgen::InsensitiveStr::Ascii("mant"), + dictgen::InsensitiveStr::Ascii("mantaries"), + dictgen::InsensitiveStr::Ascii("mantary"), + dictgen::InsensitiveStr::Ascii("mantation"), + dictgen::InsensitiveStr::Ascii("mants"), + dictgen::InsensitiveStr::Ascii("mation"), + dictgen::InsensitiveStr::Ascii("memt"), + dictgen::InsensitiveStr::Ascii("men"), + dictgen::InsensitiveStr::Ascii("menatation"), + dictgen::InsensitiveStr::Ascii("menation"), + dictgen::InsensitiveStr::Ascii("menatries"), + dictgen::InsensitiveStr::Ascii("menatry"), + dictgen::InsensitiveStr::Ascii("menet"), + dictgen::InsensitiveStr::Ascii("menetation"), + dictgen::InsensitiveStr::Ascii("menets"), + dictgen::InsensitiveStr::Ascii("mentacion"), + dictgen::InsensitiveStr::Ascii("mentaion"), + dictgen::InsensitiveStr::Ascii("mentaire"), + dictgen::InsensitiveStr::Ascii("mentaires"), + dictgen::InsensitiveStr::Ascii("mentaiton"), + dictgen::InsensitiveStr::Ascii("mentare"), + dictgen::InsensitiveStr::Ascii("mentarios"), + dictgen::InsensitiveStr::Ascii("mentarse"), + dictgen::InsensitiveStr::Ascii("mentarsi"), + dictgen::InsensitiveStr::Ascii("mentataion"), + dictgen::InsensitiveStr::Ascii("mentataions"), + dictgen::InsensitiveStr::Ascii("mentaties"), + dictgen::InsensitiveStr::Ascii("mentating"), + dictgen::InsensitiveStr::Ascii("mentato"), + dictgen::InsensitiveStr::Ascii("mentaton"), + dictgen::InsensitiveStr::Ascii("menteries"), + dictgen::InsensitiveStr::Ascii("mentery"), + dictgen::InsensitiveStr::Ascii("mentes"), + dictgen::InsensitiveStr::Ascii("mention"), + dictgen::InsensitiveStr::Ascii("mentories"), + dictgen::InsensitiveStr::Ascii("mentory"), + dictgen::InsensitiveStr::Ascii("mentry"), + dictgen::InsensitiveStr::Ascii("metation"), + dictgen::InsensitiveStr::Ascii("metnation"), + dictgen::InsensitiveStr::Ascii("mment"), + dictgen::InsensitiveStr::Ascii("mments"), + dictgen::InsensitiveStr::Ascii("mnet"), + dictgen::InsensitiveStr::Ascii("mument"), + dictgen::InsensitiveStr::Ascii("nment"), ], values: &[ &["document"], - &["documented"], + &["document"], &["documents"], - &["doctrines"], - &["doctrine"], - &["doctrines"], - &["doctrines"], - &["doctrine"], - &["doctrines"], + &["document"], + &["documents"], + &["document"], + &["documentation"], + &["documented"], + &["documenting"], + &["documents"], + &["document"], + &["documentation"], &["douchebag"], &["douches"], &["douchey"], + &["document"], &["documentaries"], &["documentary"], &["documentation"], - &["documentaries"], - &["documentary"], + &["documents"], &["documentation"], - &["documentation"], - &["documentaries"], - &["documentaries"], - &["documentation"], - &["documentaries"], - &["documentaries"], - &["documentaries"], - &["documentaries"], - &["documentaries"], + &["document"], + &["document"], &["documentation"], &["documentation"], &["documentaries"], &["documentary"], + &["document"], + &["documentation"], + &["documents"], + &["documentation"], + &["documentation"], + &["documentaries"], + &["documentaries"], + &["documentation"], + &["documentaries"], + &["documentaries"], + &["documentaries"], + &["documentaries"], + &["documentation"], + &["documentations"], + &["documentaries"], + &["documentation"], + &["documentation"], + &["documentation"], + &["documentaries"], + &["documentary"], + &["documents"], + &["documentation"], &["documentaries"], &["documentary"], &["documentary"], + &["documentation"], + &["documentation"], + &["document"], + &["documents"], + &["document"], + &["document"], + &["document"], ], - range: 4..=10, + range: 3..=11, +}; + +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_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("unet"), + dictgen::InsensitiveStr::Ascii("unetation"), + dictgen::InsensitiveStr::Ascii("uneted"), + dictgen::InsensitiveStr::Ascii("uneting"), + dictgen::InsensitiveStr::Ascii("unets"), + ], + values: &[ + &["documentation"], + &["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 { @@ -63817,9 +119782,21 @@ static WORD_DOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ulelift")], - values: &[&["doublelift"]], - range: 7..=7, + 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 { @@ -63828,9 +119805,48 @@ static WORD_DOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("pmine")], - values: &[&["dopamine"]], - range: 5..=5, + keys: &[ + 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: &[ + &["dialog"], + &["domain", "dopamine"], + &["dopamine", "domain"], + &["domains"], + &["dopamine"], + &["does"], + ], + range: 1..=5, +}; + +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"), + ], + values: &[&["dynamically"], &["done"]], + 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 { @@ -63874,50 +119890,78 @@ static WORD_DIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_DIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("de"), 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("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"], &["diversify"], &["diversity"], - &["diverse"], + &["diverse", "diverged"], &["diversify"], &["diversify"], &["diversity"], + &["diversion"], + &["diversions"], + &["divot"], &["device"], + &["divider"], &["dividends"], &["dividends"], &["dividend"], &["dividend"], &["dividends"], - &["divination"], + &["divider", "divisor"], + &["dividers", "divisors"], + &["divination", "definition"], &["divinity"], &["divinity"], &["divinity"], + &["division"], + &["divisible"], &["divisions"], &["divisions"], + &["divisor"], &["division"], &["divisions"], + &["diverse"], + &["division"], + &["divisions"], + &["divisors"], ], - range: 3..=8, + range: 2..=8, }; static WORD_DIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63928,10 +119972,23 @@ static WORD_DIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_DIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("actorship"), + dictgen::InsensitiveStr::Ascii("ance"), + dictgen::InsensitiveStr::Ascii("inguishes"), + dictgen::InsensitiveStr::Ascii("ribute"), dictgen::InsensitiveStr::Ascii("ributed"), + dictgen::InsensitiveStr::Ascii("ribution"), + dictgen::InsensitiveStr::Ascii("ributions"), ], - values: &[&["dictatorship"], &["distributed"]], - range: 7..=9, + values: &[ + &["dictatorship"], + &["distance"], + &["distinguishes"], + &["distribute"], + &["distributed"], + &["distribution"], + &["distributions"], + ], + range: 4..=9, }; static WORD_DIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -63943,9 +120000,9 @@ static WORD_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_DISA_NODE), Some(&WORD_DISB_NODE), Some(&WORD_DISC_NODE), - None, + Some(&WORD_DISD_NODE), Some(&WORD_DISE_NODE), - None, + Some(&WORD_DISF_NODE), Some(&WORD_DISG_NODE), Some(&WORD_DISH_NODE), Some(&WORD_DISI_NODE), @@ -63975,22 +120032,30 @@ static WORD_DISU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"], &["disputed"], &["disputes"], &["disruption"], + &["discussion"], + &["discussions"], + &["distutils"], ], - range: 4..=7, + range: 3..=7, }; static WORD_DIST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64012,7 +120077,7 @@ static WORD_DIST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_DISTN_NODE), Some(&WORD_DISTO_NODE), None, None, @@ -64074,7 +120139,7 @@ static WORD_DISTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, Some(&WORD_DISTRC_NODE), None, - None, + Some(&WORD_DISTRE_NODE), None, None, None, @@ -64105,48 +120170,62 @@ static WORD_DISTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("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"], &["distrust"], ], - range: 3..=7, + range: 1..=7, }; static WORD_DISTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64160,12 +120239,14 @@ pub static WORD_DISTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("bution"), dictgen::InsensitiveStr::Ascii("butions"), dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("ying"), ], values: &[ &["distributed"], &["distribution"], &["distributions"], &["distortion"], + &["destroying"], ], range: 4..=7, }; @@ -64179,19 +120260,29 @@ pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("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"), @@ -64205,25 +120296,36 @@ pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], + &["distributed"], &["distribute"], &["distribute"], &["distribute"], &["distribute"], + &["distribution"], &["distribute"], &["distribute"], &["distributed"], + &["distributing"], + &["distribution"], + &["distributing"], &["distribution"], &["distributions"], &["distributor"], + &["distribute"], &["distributions"], &["distributions"], &["distributed"], @@ -64237,12 +120339,24 @@ pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["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, @@ -64300,6 +120414,7 @@ pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("rtian"), dictgen::InsensitiveStr::Ascii("rto"), dictgen::InsensitiveStr::Ascii("rtron"), + dictgen::InsensitiveStr::Ascii("ry"), ], values: &[ &["distortion"], @@ -64307,8 +120422,44 @@ pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["distortion"], &["distortion"], &["distortion"], + &["destroy", "distort", "history"], ], - range: 3..=5, + range: 2..=5, +}; + +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 { @@ -64318,10 +120469,19 @@ static WORD_DISTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("nations"), dictgen::InsensitiveStr::Ascii("ncion"), dictgen::InsensitiveStr::Ascii("nciton"), @@ -64344,26 +120504,44 @@ pub static WORD_DISTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("nguised"), 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("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"], &["distinctions"], &["distinction"], &["distinction"], @@ -64386,22 +120564,31 @@ pub static WORD_DISTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["distinguished"], &["distinguishing"], &["distinguish"], + &["distinguished"], + &["distinguishes"], + &["distinguishing"], + &["distinguish"], &["distinguishing"], &["distinction"], &["distinguish"], + &["distinguishable"], &["distinguished"], &["distinguishing"], &["distinct"], &["distinctly"], + &["distinctions"], &["disturbance"], &["distribute"], + &["distribute", "distributed"], + &["distributes"], &["distributing"], &["distribution"], &["distributions"], &["distributor"], + &["distorted"], &["distinguished"], ], - range: 2..=9, + range: 2..=10, }; static WORD_DISTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64410,9 +120597,12 @@ static WORD_DISTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_DISTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rbance")], - values: &[&["disturbance"]], - range: 6..=6, + 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 { @@ -64422,16 +120612,24 @@ static WORD_DISTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ncef"), + 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: &[ + &["distanced", "distances", "distance"], + &["distance"], + &["distract"], &["distaste"], &["distasteful"], + &["disaster"], &["distaste"], &["distasteful"], &["distaste"], @@ -64441,74 +120639,507 @@ pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_DISS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DISS_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DISS_CHILDREN), value: None, }; -pub static WORD_DISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("agreement"), - dictgen::InsensitiveStr::Ascii("apear"), - dictgen::InsensitiveStr::Ascii("apearance"), - dictgen::InsensitiveStr::Ascii("apeared"), - dictgen::InsensitiveStr::Ascii("apearing"), - dictgen::InsensitiveStr::Ascii("apears"), - dictgen::InsensitiveStr::Ascii("apionted"), - dictgen::InsensitiveStr::Ascii("apoimted"), - dictgen::InsensitiveStr::Ascii("apoined"), - dictgen::InsensitiveStr::Ascii("apointd"), - dictgen::InsensitiveStr::Ascii("apointed"), - dictgen::InsensitiveStr::Ascii("apointted"), - dictgen::InsensitiveStr::Ascii("apoited"), - dictgen::InsensitiveStr::Ascii("apoitned"), - dictgen::InsensitiveStr::Ascii("aponited"), - dictgen::InsensitiveStr::Ascii("apoonted"), - dictgen::InsensitiveStr::Ascii("apounted"), - dictgen::InsensitiveStr::Ascii("appear"), - dictgen::InsensitiveStr::Ascii("appears"), - dictgen::InsensitiveStr::Ascii("appinted"), - dictgen::InsensitiveStr::Ascii("appointed"), - dictgen::InsensitiveStr::Ascii("apponted"), - dictgen::InsensitiveStr::Ascii("array"), - dictgen::InsensitiveStr::Ascii("astified"), - dictgen::InsensitiveStr::Ascii("atisfed"), - dictgen::InsensitiveStr::Ascii("atisifed"), - dictgen::InsensitiveStr::Ascii("atsified"), - dictgen::InsensitiveStr::Ascii("cusion"), - dictgen::InsensitiveStr::Ascii("cusions"), - dictgen::InsensitiveStr::Ascii("epointed"), - dictgen::InsensitiveStr::Ascii("ertaion"), - dictgen::InsensitiveStr::Ascii("ipatore"), - dictgen::InsensitiveStr::Ascii("ipointed"), - dictgen::InsensitiveStr::Ascii("misal"), - dictgen::InsensitiveStr::Ascii("misive"), - dictgen::InsensitiveStr::Ascii("obediance"), - dictgen::InsensitiveStr::Ascii("obediant"), - dictgen::InsensitiveStr::Ascii("obedience"), - dictgen::InsensitiveStr::Ascii("obedient"), - dictgen::InsensitiveStr::Ascii("odance"), - dictgen::InsensitiveStr::Ascii("ole"), - dictgen::InsensitiveStr::Ascii("onante"), - dictgen::InsensitiveStr::Ascii("onence"), - dictgen::InsensitiveStr::Ascii("opointed"), - dictgen::InsensitiveStr::Ascii("ovle"), - dictgen::InsensitiveStr::Ascii("paointed"), - dictgen::InsensitiveStr::Ascii("piate"), - dictgen::InsensitiveStr::Ascii("ppointed"), - dictgen::InsensitiveStr::Ascii("spointed"), + 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: &[ - &["disagreement"], + &["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("miliarity"), + dictgen::InsensitiveStr::Ascii("patore"), + dictgen::InsensitiveStr::Ascii("pointed"), + ], + values: &[&["dissimilarity"], &["dissipate"], &["disappointed"]], + range: 6..=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"], @@ -64516,39 +121147,124 @@ pub static WORD_DISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disappointed"], &["disappointed"], &["disappear"], + &["disappeared"], + &["disappeared"], + &["disappearing"], + &["disappears"], + &["disappear"], + &["disappeared"], + &["disappeared"], + &["disappearing"], &["disappears"], &["disappointed"], &["disappointed"], &["disappointed"], - &["disarray"], - &["dissatisfied"], - &["dissatisfied"], - &["dissatisfied"], - &["dissatisfied"], - &["discussion"], - &["discussions"], - &["disappointed"], - &["dissertation"], - &["dissipate"], - &["disappointed"], - &["dismissal"], - &["dismissive"], - &["disobedience"], - &["disobedient"], - &["disobedience"], - &["disobedient"], - &["dissonance"], - &["dissolve"], - &["dissonance"], - &["dissonance"], - &["disappointed"], - &["dissolve"], - &["disappointed"], - &["dissipate"], - &["disappointed"], - &["disappointed"], + &["disapprove"], + &["disapproves"], ], - range: 3..=9, + 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 { @@ -64564,6 +121280,7 @@ pub static WORD_DISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ecpecting"), dictgen::InsensitiveStr::Ascii("ection"), dictgen::InsensitiveStr::Ascii("egaring"), + dictgen::InsensitiveStr::Ascii("egrad"), dictgen::InsensitiveStr::Ascii("epresentation"), dictgen::InsensitiveStr::Ascii("epsect"), dictgen::InsensitiveStr::Ascii("epsected"), @@ -64580,11 +121297,15 @@ pub static WORD_DISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -64598,6 +121319,7 @@ pub static WORD_DISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disrespecting"], &["discretion"], &["disregarding"], + &["disregard"], &["misrepresentation"], &["disrespect"], &["disrespected"], @@ -64614,18 +121336,22 @@ pub static WORD_DISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disrespect"], &["disrespected"], &["disrespecting"], + &["discrete"], + &["discretion"], + &["distribution"], &["districts"], &["disruption"], &["disrespect"], &["disrespectful"], &["disrespecting"], + &["disarm"], &["disrupting"], &["distributions"], &["disruption"], &["disruption"], &["disruption"], ], - range: 4..=13, + range: 1..=13, }; static WORD_DISQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64656,7 +121382,7 @@ static WORD_DISP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_DISPA_NODE), - None, + Some(&WORD_DISPB_NODE), None, None, Some(&WORD_DISPE_NODE), @@ -64670,7 +121396,7 @@ static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_DISPO_NODE), - None, + Some(&WORD_DISPP_NODE), None, Some(&WORD_DISPR_NODE), None, @@ -64758,6 +121484,17 @@ pub static WORD_DISPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -64765,28 +121502,46 @@ static WORD_DISPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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"], + &["disposal"], &["disposition"], &["disposition"], &["dispose"], + &["disposable"], + &["disposal"], + &["dispose"], + &["disposed", "dispossessed"], + &["disposes", "dispossess"], + &["disposing"], &["dispose"], &["disposition"], &["dispose"], ], - range: 3..=13, + range: 2..=13, }; static WORD_DISPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64796,18 +121551,36 @@ static WORD_DISPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_DISPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("a"), dictgen::InsensitiveStr::Ascii("acemnt"), + dictgen::InsensitiveStr::Ascii("acment"), + dictgen::InsensitiveStr::Ascii("acments"), 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"], + &["displacement"], + &["displacements"], &["displayed"], + &["displays", "displayed"], &["displays"], + &["displayed"], + &["displaying"], + &["display"], + &["displayed"], + &["displaying"], &["displays"], ], - range: 3..=6, + range: 1..=7, }; static WORD_DISPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64832,6 +121605,7 @@ static WORD_DISPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -64850,10 +121624,12 @@ pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], @@ -64872,9 +121648,21 @@ pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["dispensary"], &["disproportionate"], &["dispensary"], + &["dispersion"], &["dispensary"], ], - range: 3..=11, + 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 { @@ -64884,30 +121672,50 @@ static WORD_DISPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("ly"), dictgen::InsensitiveStr::Ascii("lyed"), + 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("th"), + dictgen::InsensitiveStr::Ascii("thed"), + dictgen::InsensitiveStr::Ascii("thes"), + dictgen::InsensitiveStr::Ascii("thing"), + dictgen::InsensitiveStr::Ascii("y"), + dictgen::InsensitiveStr::Ascii("yport"), ], values: &[ + &["dispatched"], &["dispatch"], &["despair"], &["disparity"], &["displacement"], + &["display"], &["displayed"], + &["displaying"], &["displays"], &["disappointed"], &["disparagingly"], + &["disparate"], &["disparity"], &["dispatch"], + &["dispatch"], + &["dispatched"], + &["dispatches"], + &["dispatching"], + &["display"], + &["displayport"], ], - range: 2..=7, + range: 1..=7, }; static WORD_DISO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -64921,18 +121729,30 @@ pub static WORD_DISO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("vering"), + dictgen::InsensitiveStr::Ascii("very"), ], values: &[ &["disobedience"], &["disobedient"], &["disobedience"], &["discography"], + &["display"], &["disillusioned"], + &["dissolve"], &["dissolved"], + &["disconnect"], + &["disconnected"], &["discover"], + &["discovering"], + &["discovery"], ], range: 3..=9, }; @@ -64943,8 +121763,11 @@ static WORD_DISN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_DISN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("egage")], - values: &[&["disengage"]], + keys: &[ + dictgen::InsensitiveStr::Ascii("abled"), + dictgen::InsensitiveStr::Ascii("egage"), + ], + values: &[&["disabled"], &["disengage"]], range: 5..=5, }; @@ -64990,12 +121813,34 @@ static WORD_DISL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["dislikes"], &["dislikes"]], - range: 3..=6, + 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 { @@ -65004,9 +121849,23 @@ static WORD_DISK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_DISK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rimination")], - values: &[&["discrimination"]], - range: 10..=10, + 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 { @@ -65020,6 +121879,8 @@ pub static WORD_DISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -65027,15 +121888,19 @@ pub static WORD_DISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ngenious"), 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"), ], values: &[ &["disciples"], &["discipline"], &["disciplined"], &["disciplines"], + &["design"], + &["designated"], &["disillusioned"], &["disillusioned"], &["disillusioned"], @@ -65043,11 +121908,13 @@ pub static WORD_DISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disingenuous"], &["disingenuous"], &["disingenuous"], + &["distinguish"], &["disinterested"], &["disinterested"], &["disciplined"], + &["desired"], ], - range: 5..=10, + range: 2..=10, }; static WORD_DISH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65057,6 +121924,7 @@ static WORD_DISH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -65065,6 +121933,7 @@ pub static WORD_DISH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("onord"), ], values: &[ + &["discharge"], &["discharged"], &["dishonored"], &["dishonored"], @@ -65082,10 +121951,17 @@ static WORD_DISG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"), @@ -65095,6 +121971,7 @@ pub static WORD_DISG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -65111,10 +121988,17 @@ pub static WORD_DISG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ustus"), ], values: &[ + &["discarded", "discarted"], &["disagreements"], &["disagrees"], &["disguise"], &["disguised"], + &["design"], + &["designed"], + &["designer"], + &["diagnostic"], + &["diagnostics"], + &["designs"], &["disgraceful"], &["disgraceful"], &["disgraceful"], @@ -65124,6 +122008,7 @@ pub static WORD_DISG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disgruntled"], &["disgruntled"], &["disguise"], + &["disgusting"], &["disgustingly"], &["disguised"], &["disgusts"], @@ -65139,7 +122024,21 @@ pub static WORD_DISG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disgusts"], &["disgusts"], ], - range: 3..=8, + 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 { @@ -65149,24 +122048,43 @@ static WORD_DISE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DISE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[ + &["dissection"], + &["deselect"], &["dissemination"], &["disenchanted"], + &["discouraged"], &["disingenuous"], &["disingenuous"], &["desensitized"], &["dysentery"], &["desirable"], + &["dissertation"], ], - range: 4..=8, + 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 { @@ -65177,7 +122095,7 @@ static WORD_DISC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_DISC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_DISCA_NODE), None, - None, + Some(&WORD_DISCC_NODE), None, Some(&WORD_DISCE_NODE), None, @@ -65211,21 +122129,31 @@ static WORD_DISCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_DISCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("alified"), + dictgen::InsensitiveStr::Ascii("assed"), + dictgen::InsensitiveStr::Ascii("sion"), 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"], + &["discussion"], &["discussions"], &["discussion"], &["discussing"], + &["discussion"], &["discussions"], - &["discussing"], + &["discussions"], + &["discussing", "disgusting"], &["disgustingly"], + &["discussion"], ], range: 4..=7, }; @@ -65239,10 +122167,20 @@ pub static WORD_DISCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], &["distinctions"]], - range: 7..=7, + values: &[ + &["distinction"], + &["distinctive"], + &["distinguish"], + &["distinctions"], + &["dictionaries"], + &["dictionary"], + ], + range: 6..=8, }; static WORD_DISCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65253,12 +122191,17 @@ static WORD_DISCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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"), @@ -65281,17 +122224,24 @@ pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("imine"), dictgen::InsensitiveStr::Ascii("iminitory"), dictgen::InsensitiveStr::Ascii("iminted"), + dictgen::InsensitiveStr::Ascii("iption"), + dictgen::InsensitiveStr::Ascii("iptions"), dictgen::InsensitiveStr::Ascii("ouage"), dictgen::InsensitiveStr::Ascii("ption"), ], values: &[ &["discrepancy"], + &["discards"], &["discretion"], &["discredited"], &["discredited"], &["discredited"], &["discredited"], + &["discriminates"], &["discrepancy"], + &["discrepancies"], + &["discrepancy"], + &["discrepancies"], &["discretion"], &["discretion"], &["discredited"], @@ -65314,6 +122264,8 @@ pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["discriminate"], &["discriminatory"], &["discriminated"], + &["description"], + &["descriptions"], &["discourages"], &["discretion"], ], @@ -65321,88 +122273,282 @@ pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_DISCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DISCO_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DISCO_CHILDREN), value: None, }; -pub static WORD_DISCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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("grahy"), - dictgen::InsensitiveStr::Ascii("grapy"), - dictgen::InsensitiveStr::Ascii("grophy"), - dictgen::InsensitiveStr::Ascii("grpahy"), - dictgen::InsensitiveStr::Ascii("lsure"), - dictgen::InsensitiveStr::Ascii("nenct"), - dictgen::InsensitiveStr::Ascii("nencted"), - dictgen::InsensitiveStr::Ascii("nencts"), - dictgen::InsensitiveStr::Ascii("nncet"), - dictgen::InsensitiveStr::Ascii("nnecters"), - dictgen::InsensitiveStr::Ascii("nnectes"), - dictgen::InsensitiveStr::Ascii("nnectme"), - dictgen::InsensitiveStr::Ascii("nnectus"), - dictgen::InsensitiveStr::Ascii("nnet"), - dictgen::InsensitiveStr::Ascii("nneted"), - dictgen::InsensitiveStr::Ascii("nnets"), - dictgen::InsensitiveStr::Ascii("nnnect"), + 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: &[ + &["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("ntinuted"), - dictgen::InsensitiveStr::Ascii("ntiued"), - dictgen::InsensitiveStr::Ascii("ntiuned"), - dictgen::InsensitiveStr::Ascii("ntued"), - dictgen::InsensitiveStr::Ascii("ruage"), - dictgen::InsensitiveStr::Ascii("sure"), - dictgen::InsensitiveStr::Ascii("und"), - dictgen::InsensitiveStr::Ascii("untined"), - dictgen::InsensitiveStr::Ascii("urces"), - dictgen::InsensitiveStr::Ascii("ure"), - dictgen::InsensitiveStr::Ascii("urgae"), - dictgen::InsensitiveStr::Ascii("urges"), - dictgen::InsensitiveStr::Ascii("ved"), - dictgen::InsensitiveStr::Ascii("verd"), - dictgen::InsensitiveStr::Ascii("vere"), - dictgen::InsensitiveStr::Ascii("veres"), - dictgen::InsensitiveStr::Ascii("veryd"), - dictgen::InsensitiveStr::Ascii("verys"), + 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_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("uage")], + values: &[&["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("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"], + &["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"], - &["disclosure"], - &["disconnect"], - &["disconnected"], - &["disconnects"], - &["disconnects"], - &["disconnects"], - &["disconnects"], - &["disconnected"], - &["disconnects"], - &["disconnect"], - &["disconnected"], - &["disconnects"], - &["disconnect"], - &["discontinued"], - &["discontinued"], - &["discontinued"], - &["discontinued"], - &["discounted"], - &["discourages"], - &["discourse"], - &["discounted"], - &["discontinued"], - &["discourse"], - &["discourse"], - &["discourages"], - &["discourages"], - &["discovered"], - &["discovered"], - &["discoveries"], - &["discovers"], - &["discovered"], - &["discovers"], ], - range: 3..=8, + range: 4..=5, }; static WORD_DISCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65445,6 +122591,7 @@ static WORD_DISCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -65464,6 +122611,7 @@ pub static WORD_DISCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("prine"), ], values: &[ + &["dissemination"], &["disciplinary"], &["disciplinary"], &["disciplines"], @@ -65496,7 +122644,11 @@ pub static WORD_DISCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("arded"), dictgen::InsensitiveStr::Ascii("are"), ], - values: &[&["discharged"], &["discharged"], &["discharged"]], + values: &[ + &["discharged"], + &["discharged"], + &["discharged", "discharge"], + ], range: 3..=5, }; @@ -65509,12 +122661,93 @@ pub static WORD_DISCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("pline"), dictgen::InsensitiveStr::Ascii("ption"), + dictgen::InsensitiveStr::Ascii("rnable"), dictgen::InsensitiveStr::Ascii("rtation"), ], - values: &[&["discipline"], &["discretion"], &["dissertation"]], + 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, @@ -65524,9 +122757,18 @@ pub static WORD_DISCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("limer"), dictgen::InsensitiveStr::Ascii("pline"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("reded"), + dictgen::InsensitiveStr::Ascii("rge"), ], - values: &[&["disclaimer"], &["discipline"]], - range: 5..=5, + values: &[ + &["disclaimer"], + &["discipline"], + &["discarded"], + &["discarded"], + &["discharge"], + ], + range: 3..=5, }; static WORD_DISB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65543,6 +122785,8 @@ pub static WORD_DISB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("eleif"), dictgen::InsensitiveStr::Ascii("elif"), dictgen::InsensitiveStr::Ascii("elife"), + dictgen::InsensitiveStr::Ascii("le"), + dictgen::InsensitiveStr::Ascii("led"), ], values: &[ &["disable"], @@ -65552,131 +122796,63 @@ pub static WORD_DISB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disbelief"], &["disbelief"], &["disbelief"], + &["disable"], + &["disabled"], ], - range: 3..=5, + range: 2..=5, }; static WORD_DISA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DISA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DISA_CHILDREN), value: None, }; -pub static WORD_DISA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("apoint"), - dictgen::InsensitiveStr::Ascii("apointed"), - dictgen::InsensitiveStr::Ascii("beld"), - dictgen::InsensitiveStr::Ascii("bels"), - dictgen::InsensitiveStr::Ascii("dvandage"), - dictgen::InsensitiveStr::Ascii("dvandages"), - dictgen::InsensitiveStr::Ascii("dvantadge"), - dictgen::InsensitiveStr::Ascii("dvanteged"), - dictgen::InsensitiveStr::Ascii("dvanteges"), - dictgen::InsensitiveStr::Ascii("dvantge"), - dictgen::InsensitiveStr::Ascii("dvantged"), - dictgen::InsensitiveStr::Ascii("dvantges"), - dictgen::InsensitiveStr::Ascii("dvatange"), - dictgen::InsensitiveStr::Ascii("dvatanges"), - dictgen::InsensitiveStr::Ascii("dventage"), - dictgen::InsensitiveStr::Ascii("dventaged"), - dictgen::InsensitiveStr::Ascii("dventages"), - dictgen::InsensitiveStr::Ascii("gred"), - dictgen::InsensitiveStr::Ascii("greeed"), - dictgen::InsensitiveStr::Ascii("greemet"), - dictgen::InsensitiveStr::Ascii("greemtn"), - dictgen::InsensitiveStr::Ascii("gremeent"), - dictgen::InsensitiveStr::Ascii("gres"), - dictgen::InsensitiveStr::Ascii("llusioned"), - dictgen::InsensitiveStr::Ascii("peared"), - dictgen::InsensitiveStr::Ascii("pointing"), - dictgen::InsensitiveStr::Ascii("ppeard"), - dictgen::InsensitiveStr::Ascii("ppearence"), - dictgen::InsensitiveStr::Ascii("ppearnace"), - dictgen::InsensitiveStr::Ascii("ppearnce"), - dictgen::InsensitiveStr::Ascii("ppearred"), - dictgen::InsensitiveStr::Ascii("ppearring"), - dictgen::InsensitiveStr::Ascii("pperaing"), - dictgen::InsensitiveStr::Ascii("pperead"), - dictgen::InsensitiveStr::Ascii("ppered"), - dictgen::InsensitiveStr::Ascii("ppiont"), - dictgen::InsensitiveStr::Ascii("pporval"), - dictgen::InsensitiveStr::Ascii("pprovel"), - dictgen::InsensitiveStr::Ascii("prity"), - dictgen::InsensitiveStr::Ascii("proval"), - dictgen::InsensitiveStr::Ascii("spointed"), - dictgen::InsensitiveStr::Ascii("sterous"), - dictgen::InsensitiveStr::Ascii("stisfied"), - dictgen::InsensitiveStr::Ascii("storus"), - dictgen::InsensitiveStr::Ascii("streous"), - dictgen::InsensitiveStr::Ascii("strious"), - dictgen::InsensitiveStr::Ascii("stros"), - dictgen::InsensitiveStr::Ascii("strosa"), - dictgen::InsensitiveStr::Ascii("strose"), - dictgen::InsensitiveStr::Ascii("strosi"), - dictgen::InsensitiveStr::Ascii("stroso"), - dictgen::InsensitiveStr::Ascii("struous"), - dictgen::InsensitiveStr::Ascii("terous"), - dictgen::InsensitiveStr::Ascii("tisfaction"), - dictgen::InsensitiveStr::Ascii("tisfied"), - dictgen::InsensitiveStr::Ascii("tissfied"), - dictgen::InsensitiveStr::Ascii("trous"), - dictgen::InsensitiveStr::Ascii("tvantage"), - dictgen::InsensitiveStr::Ascii("tvantaged"), - dictgen::InsensitiveStr::Ascii("tvantages"), + 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: &[ - &["disappoint"], - &["disappointed"], - &["disabled"], - &["disables"], - &["disadvantaged"], - &["disadvantaged"], - &["disadvantaged"], - &["disadvantaged"], - &["disadvantages"], - &["disadvantage"], - &["disadvantaged"], - &["disadvantages"], - &["disadvantage"], - &["disadvantages"], - &["disadvantage"], - &["disadvantaged"], - &["disadvantages"], - &["disagreed"], - &["disagreed"], - &["disagreements"], - &["disagreements"], - &["disagreements"], - &["disagrees"], - &["disillusioned"], - &["disappeared"], - &["disappointing"], - &["disappeared"], - &["disappearance"], - &["disappearance"], - &["disappearance"], - &["disappeared"], - &["disappearing"], - &["disappearing"], - &["disappeared"], - &["disappeared"], - &["disappoint"], - &["disapproval"], - &["disapproval"], - &["disparity"], - &["disapproval"], - &["disappointed"], - &["disastrous"], - &["dissatisfied"], - &["disastrous"], - &["disastrous"], - &["disastrous"], - &["disastrous"], - &["disastrous"], - &["disastrous"], - &["disastrous"], - &["disastrous"], - &["disastrous"], &["disastrous"], &["dissatisfaction"], &["dissatisfied"], @@ -65686,74 +122862,671 @@ pub static WORD_DISA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["disadvantaged"], &["disadvantages"], ], - range: 4..=10, + range: 4..=9, }; -static WORD_DIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DIR_CHILDREN), +static WORD_DISAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_DISAS_CHILDREN), value: None, }; -pub static WORD_DIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_DISAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("bble"), - dictgen::InsensitiveStr::Ascii("eccional"), - dictgen::InsensitiveStr::Ascii("ecitonal"), - dictgen::InsensitiveStr::Ascii("eclty"), - dictgen::InsensitiveStr::Ascii("ecotry"), - dictgen::InsensitiveStr::Ascii("ectin"), - dictgen::InsensitiveStr::Ascii("ectinla"), - dictgen::InsensitiveStr::Ascii("ectionl"), - dictgen::InsensitiveStr::Ascii("ectionnal"), - dictgen::InsensitiveStr::Ascii("ectivos"), - dictgen::InsensitiveStr::Ascii("ectix"), - dictgen::InsensitiveStr::Ascii("ectores"), - dictgen::InsensitiveStr::Ascii("ectorguy"), - dictgen::InsensitiveStr::Ascii("ectorios"), - dictgen::InsensitiveStr::Ascii("ectorys"), - dictgen::InsensitiveStr::Ascii("ectos"), - dictgen::InsensitiveStr::Ascii("ectoty"), - dictgen::InsensitiveStr::Ascii("ectoy"), - dictgen::InsensitiveStr::Ascii("ectroy"), - dictgen::InsensitiveStr::Ascii("ectrx"), - dictgen::InsensitiveStr::Ascii("ectsong"), - dictgen::InsensitiveStr::Ascii("ecty"), - dictgen::InsensitiveStr::Ascii("ektional"), - dictgen::InsensitiveStr::Ascii("etcx"), - dictgen::InsensitiveStr::Ascii("fting"), - dictgen::InsensitiveStr::Ascii("ived"), - dictgen::InsensitiveStr::Ascii("vers"), + 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: &[ - &["dribble"], - &["directional"], - &["directional"], - &["directly"], - &["directory"], - &["directions"], - &["directional"], - &["directional"], - &["directional"], - &["directions"], - &["directx"], - &["directors"], - &["directory"], - &["directors"], - &["directors"], - &["directors"], - &["directory"], - &["directory"], - &["directory"], - &["directx"], - &["directions"], - &["directly"], - &["directional"], - &["directx"], - &["drifting"], - &["derived"], - &["drivers"], + &["disappointed"], + &["disassembled"], + &["disassociate"], + &["disassociation"], + &["disassembler"], + &["disastrous"], + &["dissatisfied"], + &["disastrous"], + &["disastrous"], + &["disastrous"], + &["disastrous"], + &["disastrous"], + &["disastrous"], + &["disastrous"], + &["disastrous"], + &["disastrous"], ], - range: 4..=9, + 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("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("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("peread"), + dictgen::InsensitiveStr::Ascii("pered"), + dictgen::InsensitiveStr::Ascii("pering"), + dictgen::InsensitiveStr::Ascii("pers"), + dictgen::InsensitiveStr::Ascii("piont"), + dictgen::InsensitiveStr::Ascii("porval"), + 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: &[ + &["disappear"], + &["disappeared"], + &["disappeared"], + &["disappearing"], + &["disappears"], + &["discipline"], + &["disappoint"], + &["disappointed"], + &["disappointing"], + &["disappeared"], + &["disappeared"], + &["disappearance"], + &["disappearance"], + &["disappearance"], + &["disappeared"], + &["disappearing"], + &["disappear"], + &["disappearing"], + &["disappeared"], + &["disappeared"], + &["disappearing"], + &["disappears"], + &["disappoint"], + &["disapproval"], + &["disapproval"], + &["disapprove"], + &["disapproved"], + &["disapproves"], + &["disapproving"], + &["disapproval"], + &["disparity"], + &["disapproval"], + ], + range: 3..=8, +}; + +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("eld"), + dictgen::InsensitiveStr::Ascii("eling"), + dictgen::InsensitiveStr::Ascii("els"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("l"), + ], + values: &[ + &["disable"], + &["disabled"], + &["disabling"], + &["disables"], + &["disables"], + &["disable"], + ], + range: 1..=5, +}; + +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")], + values: &[&["directional"]], + range: 6..=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::Flat(&WORD_DIREC_CHILDREN), + value: None, +}; + +pub static WORD_DIREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("cion"), + dictgen::InsensitiveStr::Ascii("cional"), + dictgen::InsensitiveStr::Ascii("ctory"), + dictgen::InsensitiveStr::Ascii("ctorys"), + dictgen::InsensitiveStr::Ascii("ctries"), + dictgen::InsensitiveStr::Ascii("itonal"), + dictgen::InsensitiveStr::Ascii("lty"), + dictgen::InsensitiveStr::Ascii("ly"), + dictgen::InsensitiveStr::Ascii("ories"), + dictgen::InsensitiveStr::Ascii("ory"), + dictgen::InsensitiveStr::Ascii("otories"), + dictgen::InsensitiveStr::Ascii("otory"), + dictgen::InsensitiveStr::Ascii("otries"), + dictgen::InsensitiveStr::Ascii("otry"), + dictgen::InsensitiveStr::Ascii("oty"), + dictgen::InsensitiveStr::Ascii("td"), + dictgen::InsensitiveStr::Ascii("tely"), + dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("tgories"), + dictgen::InsensitiveStr::Ascii("tgory"), + dictgen::InsensitiveStr::Ascii("tin"), + dictgen::InsensitiveStr::Ascii("tinla"), + dictgen::InsensitiveStr::Ascii("tionl"), + dictgen::InsensitiveStr::Ascii("tionnal"), + dictgen::InsensitiveStr::Ascii("tivos"), + dictgen::InsensitiveStr::Ascii("tix"), + dictgen::InsensitiveStr::Ascii("toies"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tores"), + dictgen::InsensitiveStr::Ascii("torguy"), + dictgen::InsensitiveStr::Ascii("torios"), + dictgen::InsensitiveStr::Ascii("toris"), + dictgen::InsensitiveStr::Ascii("tort"), + dictgen::InsensitiveStr::Ascii("torty"), + dictgen::InsensitiveStr::Ascii("torys"), + dictgen::InsensitiveStr::Ascii("tos"), + dictgen::InsensitiveStr::Ascii("toty"), + dictgen::InsensitiveStr::Ascii("toy"), + dictgen::InsensitiveStr::Ascii("tpries"), + dictgen::InsensitiveStr::Ascii("tpry"), + dictgen::InsensitiveStr::Ascii("tries"), + dictgen::InsensitiveStr::Ascii("trive"), + dictgen::InsensitiveStr::Ascii("trives"), + dictgen::InsensitiveStr::Ascii("trly"), + dictgen::InsensitiveStr::Ascii("troies"), + dictgen::InsensitiveStr::Ascii("trories"), + dictgen::InsensitiveStr::Ascii("trory"), + dictgen::InsensitiveStr::Ascii("troy"), + dictgen::InsensitiveStr::Ascii("trx"), + dictgen::InsensitiveStr::Ascii("try"), + dictgen::InsensitiveStr::Ascii("tsion"), + dictgen::InsensitiveStr::Ascii("tsions"), + dictgen::InsensitiveStr::Ascii("tsong"), + dictgen::InsensitiveStr::Ascii("ttories"), + dictgen::InsensitiveStr::Ascii("ttory"), + dictgen::InsensitiveStr::Ascii("ty"), + ], + values: &[ + &["direction"], + &["directional"], + &["directory"], + &["directories"], + &["directories"], + &["directional"], + &["directly"], + &["directly"], + &["directories"], + &["directory"], + &["directories"], + &["directory"], + &["directories"], + &["directory"], + &["directory"], + &["directed"], + &["directly"], + &["directs"], + &["directories"], + &["directory"], + &["directions"], + &["directional"], + &["directional"], + &["directional"], + &["directions"], + &["directx"], + &["directories"], + &["direction"], + &["directors", "directories"], + &["directory"], + &["directors"], + &["directories"], + &["directory"], + &["directory"], + &["directors", "directories"], + &["directors"], + &["directory"], + &["directory"], + &["directories"], + &["directory"], + &["directories"], + &["directive"], + &["directives"], + &["directly"], + &["directories"], + &["directories"], + &["directory"], + &["directory"], + &["directx"], + &["directory"], + &["direction"], + &["directions"], + &["directions"], + &["directories"], + &["directory"], + &["directly"], + ], + range: 2..=7, +}; + +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 { @@ -65766,6 +123539,10 @@ pub static WORD_DIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ections"), dictgen::InsensitiveStr::Ascii("htong"), dictgen::InsensitiveStr::Ascii("htongs"), + 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"), @@ -65773,6 +123550,9 @@ pub static WORD_DIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("thong"), dictgen::InsensitiveStr::Ascii("thongs"), ], @@ -65780,6 +123560,10 @@ pub static WORD_DIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["depictions"], &["diphthong"], &["diphthongs"], + &["display"], + &["displayed"], + &["displaying"], + &["displays"], &["diplomatic"], &["diplomatic"], &["diplomacy"], @@ -65787,10 +123571,13 @@ pub static WORD_DIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["diploma"], &["diploma"], &["diplomatic"], + &["dispose", "depose"], + &["disposed", "deposed"], + &["disposing", "deposing"], &["diphthong"], &["diphthongs"], ], - range: 4..=9, + range: 3..=9, }; static WORD_DIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65815,9 +123602,15 @@ static WORD_DIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("gity"), + dictgen::InsensitiveStr::Ascii("maic"), dictgen::InsensitiveStr::Ascii("osar"), dictgen::InsensitiveStr::Ascii("osaures"), dictgen::InsensitiveStr::Ascii("osaurios"), @@ -65827,11 +123620,18 @@ pub static WORD_DIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("osuars"), dictgen::InsensitiveStr::Ascii("soaur"), dictgen::InsensitiveStr::Ascii("soaurs"), + dictgen::InsensitiveStr::Ascii("teractively"), ], values: &[ + &["dynamic"], + &["dynamically"], + &["dynamically"], + &["dynamically"], + &["dynamically"], &["dinosaur"], &["dinosaurs"], &["dignity"], + &["dynamic"], &["dinosaur"], &["dinosaurs"], &["dinosaurs"], @@ -65841,8 +123641,9 @@ pub static WORD_DIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["dinosaurs"], &["dinosaur"], &["dinosaurs"], + &["interactively"], ], - range: 4..=8, + range: 4..=11, }; static WORD_DIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65854,15 +123655,32 @@ pub static WORD_DIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ 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("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"), @@ -65870,22 +123688,48 @@ pub static WORD_DIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("unitive"), ], values: &[ &["diamond"], &["diamonds"], &["dimensions"], + &["dimension", "dominion"], &["dimensional"], + &["dimensionalities"], + &["dimensionality"], + &["dimensions"], + &["dimensional"], + &["dimensionalities"], + &["dimensionality"], + &["dimension"], + &["dimensional"], + &["dimensional"], + &["dimensionality"], &["dimensions"], &["dimensions"], &["dimensional"], &["dimensional"], + &["dimensional"], + &["dimension"], + &["dimensions"], &["dimension"], &["dimensional"], + &["dimensional"], + &["dimensional"], + &["dimensions"], &["dimensions"], &["dimension"], &["dimensional"], @@ -65894,12 +123738,21 @@ pub static WORD_DIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["diminishes"], &["diminishes"], &["diminishing"], + &["diminish"], + &["diminished"], &["diminishing"], &["diminutive"], &["diminishing"], + &["dismissed"], + &["dimension"], + &["dimensioned"], + &["dimensioning"], + &["dimensions"], + &["dimension"], + &["dimension"], &["diminutive"], ], - range: 4..=9, + range: 4..=13, }; static WORD_DIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65908,9 +123761,25 @@ static WORD_DIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("poma")], - values: &[&["diploma"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ema"), + dictgen::InsensitiveStr::Ascii("emas"), + dictgen::InsensitiveStr::Ascii("ineate"), + dictgen::InsensitiveStr::Ascii("lema"), + dictgen::InsensitiveStr::Ascii("lemas"), + dictgen::InsensitiveStr::Ascii("limport"), + dictgen::InsensitiveStr::Ascii("poma"), + ], + values: &[ + &["dilemma"], + &["dilemmas"], + &["delineate"], + &["dilemma"], + &["dilemmas"], + &["dllimport"], + &["diploma"], + ], + range: 3..=7, }; static WORD_DIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -65924,133 +123793,644 @@ pub static WORD_DIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("itial"), + dictgen::InsensitiveStr::Ascii("itis"), dictgen::InsensitiveStr::Ascii("nitiy"), + dictgen::InsensitiveStr::Ascii("nostics"), ], values: &[ &["diagnose"], &["diagnosed"], &["diagnosis"], &["diagnostic"], + &["digest"], + &["digit"], + &["digital"], + &["digits"], + &["digital"], + &["digital"], + &["digits"], &["dignity"], + &["diagnostics"], ], - range: 5..=7, + range: 3..=7, }; static WORD_DIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DIF_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DIF_CHILDREN), value: None, }; -pub static WORD_DIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("enitly"), - dictgen::InsensitiveStr::Ascii("erent"), - dictgen::InsensitiveStr::Ascii("errent"), - dictgen::InsensitiveStr::Ascii("ferance"), - dictgen::InsensitiveStr::Ascii("ferances"), - dictgen::InsensitiveStr::Ascii("ferantiate"), - dictgen::InsensitiveStr::Ascii("ferantiation"), - dictgen::InsensitiveStr::Ascii("ferantly"), - dictgen::InsensitiveStr::Ascii("ferencial"), - dictgen::InsensitiveStr::Ascii("ferenciate"), - dictgen::InsensitiveStr::Ascii("ferenciation"), - dictgen::InsensitiveStr::Ascii("ferenciations"), - dictgen::InsensitiveStr::Ascii("ferencies"), - dictgen::InsensitiveStr::Ascii("ferene"), - dictgen::InsensitiveStr::Ascii("ferenly"), - dictgen::InsensitiveStr::Ascii("ferens"), - dictgen::InsensitiveStr::Ascii("ferense"), - dictgen::InsensitiveStr::Ascii("ferental"), - dictgen::InsensitiveStr::Ascii("ferentate"), - dictgen::InsensitiveStr::Ascii("ferente"), - dictgen::InsensitiveStr::Ascii("ferentes"), - dictgen::InsensitiveStr::Ascii("ferentiantion"), - dictgen::InsensitiveStr::Ascii("ferentiatiations"), - dictgen::InsensitiveStr::Ascii("ferentiatiors"), - dictgen::InsensitiveStr::Ascii("ferentiaton"), - dictgen::InsensitiveStr::Ascii("ferentitation"), - dictgen::InsensitiveStr::Ascii("ferentl"), - dictgen::InsensitiveStr::Ascii("ferenty"), - dictgen::InsensitiveStr::Ascii("fereny"), - dictgen::InsensitiveStr::Ascii("ferientation"), - dictgen::InsensitiveStr::Ascii("ferintiate"), - dictgen::InsensitiveStr::Ascii("fernece"), - dictgen::InsensitiveStr::Ascii("ferneces"), - dictgen::InsensitiveStr::Ascii("fernetial"), - dictgen::InsensitiveStr::Ascii("fernetly"), - dictgen::InsensitiveStr::Ascii("fernt"), - dictgen::InsensitiveStr::Ascii("ficulites"), - dictgen::InsensitiveStr::Ascii("ficulity"), - dictgen::InsensitiveStr::Ascii("ficulte"), - dictgen::InsensitiveStr::Ascii("ficultes"), - dictgen::InsensitiveStr::Ascii("ficults"), - dictgen::InsensitiveStr::Ascii("ficuly"), - dictgen::InsensitiveStr::Ascii("ficut"), - dictgen::InsensitiveStr::Ascii("ficutlies"), - dictgen::InsensitiveStr::Ascii("ficutly"), - dictgen::InsensitiveStr::Ascii("firentiate"), - dictgen::InsensitiveStr::Ascii("frent"), - dictgen::InsensitiveStr::Ascii("fucult"), - dictgen::InsensitiveStr::Ascii("fuculties"), - dictgen::InsensitiveStr::Ascii("fuculty"), - dictgen::InsensitiveStr::Ascii("iculties"), - dictgen::InsensitiveStr::Ascii("iculty"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("sed"), + dictgen::InsensitiveStr::Ascii("ses"), + dictgen::InsensitiveStr::Ascii("ssion"), + dictgen::InsensitiveStr::Ascii("ssive"), ], values: &[ - &["definitely"], - &["different"], + &["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("lt"), + dictgen::InsensitiveStr::Ascii("ssion"), + dictgen::InsensitiveStr::Ascii("ssive"), + ], + values: &[ + &["difficult"], + &["difficulties"], + &["difficulty"], + &["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"], - &["differentiate"], - &["differentiation"], - &["differently"], + &["different"], &["differential"], &["differentiate"], - &["differentiation"], - &["differentiation"], - &["differences"], - &["differences"], + &["differentiated"], &["differently"], - &["differences"], - &["differences"], - &["differential"], - &["differentiate"], + &["different", "difference"], &["difference"], &["differences"], - &["differentiation"], - &["differentiations"], - &["differentiation"], - &["differentiation"], - &["differentiation"], - &["differential"], - &["differently"], - &["differently"], - &["differentiation"], - &["differentiate"], - &["difference"], - &["differences"], - &["differential"], - &["differently"], - &["different"], - &["difficulties"], - &["difficulty"], - &["difficulties"], - &["difficulties"], - &["difficulties"], - &["difficulty"], - &["difficulty"], - &["difficulties"], - &["difficulty"], - &["differentiate"], - &["different"], + ], + 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: 5..=16, + 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("erent"), + dictgen::InsensitiveStr::Ascii("erently"), + dictgen::InsensitiveStr::Ascii("ers"), + ], + values: &[ + &["differed"], + &["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("ent"), + ], + values: &[&["differed"], &["difference"], &["different"]], + range: 2..=4, + }; + +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("ct"), + dictgen::InsensitiveStr::Ascii("n"), + 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("tnt"), + ], + values: &[ + &["different"], + &["different"], + &["differential"], + &["differentiate"], + &["differentiated"], + &["differentiates"], + &["differentiating"], + &["differentiation"], + &["differentiation"], + &["differences"], + &["different"], + &["different"], + &["differences", "difference"], + &["differences"], + &["differently"], + &["differences", "difference"], + &["differences", "difference"], + &["differential"], + &["differentiate"], + &["difference"], + &["differences"], + &["differentiation"], + &["differentiations"], + &["differentiation"], + &["differentiation"], + &["differentiation"], + &["differential"], + &["different", "difference"], + &["differently"], + &["differently"], + &["different"], + &["differs"], + &["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"), + ], + values: &[ + &["difference"], + &["different"], + &["difference"], + &["differences"], + ], + range: 2..=6, +}; + +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("rent"), + dictgen::InsensitiveStr::Ascii("rently"), + dictgen::InsensitiveStr::Ascii("rrent"), + ], + values: &[ + &["definitely"], + &["different"], + &["differently"], + &["different"], + ], + range: 4..=6, }; static WORD_DIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66062,11 +124442,22 @@ pub static WORD_DIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("a"), 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"], &["dying"], &["deities"], &["deity"]], - range: 1..=4, + values: &[ + &["idea", "die"], + &["dying", "dyeing"], + &["dielectric"], + &["dielectrics"], + &["dimension"], + &["deities"], + &["deity"], + ], + range: 1..=8, }; static WORD_DID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66075,9 +124466,12 @@ static WORD_DID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sapointed")], - values: &[&["disappointed"]], - range: 9..=9, + 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 { @@ -66087,122 +124481,362 @@ static WORD_DIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_DIC_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("ates"), + dictgen::InsensitiveStr::Ascii("ationaries"), + dictgen::InsensitiveStr::Ascii("ationary"), + dictgen::InsensitiveStr::Ascii("ergence"), dictgen::InsensitiveStr::Ascii("homoty"), dictgen::InsensitiveStr::Ascii("hotomoy"), dictgen::InsensitiveStr::Ascii("htomy"), + dictgen::InsensitiveStr::Ascii("ionaries"), + dictgen::InsensitiveStr::Ascii("ionary"), + dictgen::InsensitiveStr::Ascii("ipline"), dictgen::InsensitiveStr::Ascii("itonaries"), dictgen::InsensitiveStr::Ascii("itonary"), dictgen::InsensitiveStr::Ascii("kisch"), dictgen::InsensitiveStr::Ascii("ksih"), + dictgen::InsensitiveStr::Ascii("line"), + dictgen::InsensitiveStr::Ascii("onnected"), + dictgen::InsensitiveStr::Ascii("onnection"), 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("rectory"), + dictgen::InsensitiveStr::Ascii("rete"), + dictgen::InsensitiveStr::Ascii("retion"), + dictgen::InsensitiveStr::Ascii("retionary"), + dictgen::InsensitiveStr::Ascii("sriminated"), dictgen::InsensitiveStr::Ascii("tadorship"), + dictgen::InsensitiveStr::Ascii("taionaries"), + dictgen::InsensitiveStr::Ascii("taionary"), dictgen::InsensitiveStr::Ascii("tarorship"), dictgen::InsensitiveStr::Ascii("taters"), dictgen::InsensitiveStr::Ascii("tateurs"), dictgen::InsensitiveStr::Ascii("tatorhip"), dictgen::InsensitiveStr::Ascii("tatorshop"), dictgen::InsensitiveStr::Ascii("tats"), + dictgen::InsensitiveStr::Ascii("tinary"), + dictgen::InsensitiveStr::Ascii("tioanries"), + dictgen::InsensitiveStr::Ascii("tioanry"), dictgen::InsensitiveStr::Ascii("tionaire"), dictgen::InsensitiveStr::Ascii("tionaires"), dictgen::InsensitiveStr::Ascii("tionairy"), dictgen::InsensitiveStr::Ascii("tionare"), dictgen::InsensitiveStr::Ascii("tionarys"), dictgen::InsensitiveStr::Ascii("tionay"), + dictgen::InsensitiveStr::Ascii("tionnaries"), dictgen::InsensitiveStr::Ascii("tionnary"), + dictgen::InsensitiveStr::Ascii("toinaries"), + dictgen::InsensitiveStr::Ascii("tonaries"), + dictgen::InsensitiveStr::Ascii("tonary"), dictgen::InsensitiveStr::Ascii("ussed"), + dictgen::InsensitiveStr::Ascii("ussions"), ], values: &[ + &["discard"], + &["discarded"], + &["discarding"], + &["discards"], + &["dictates"], + &["dictionaries"], + &["dictionary"], + &["divergence"], &["dichotomy"], &["dichotomy"], &["dichotomy"], &["dictionaries"], &["dictionary"], + &["discipline"], + &["dictionaries"], + &["dictionary"], &["dickish"], &["dickish"], + &["decline"], + &["disconnected"], + &["disconnection"], &["disconnects"], &["discover"], &["discovered"], &["discovering"], &["discovers"], &["discovery"], + &["directory"], + &["discrete"], + &["discretion"], + &["discretionary"], + &["discriminated"], &["dictatorship"], + &["dictionaries"], + &["dictionary"], &["dictatorship"], &["dictates"], &["dictates"], &["dictatorship"], &["dictatorship"], &["dictates"], + &["dictionary"], + &["dictionaries"], + &["dictionary"], &["dictionaries"], &["dictionaries"], &["dictionary"], &["dictionaries"], &["dictionaries"], &["dictionary"], + &["dictionaries"], + &["dictionary"], + &["dictionaries"], + &["dictionaries"], &["dictionary"], &["discussed"], + &["discussions"], ], - range: 4..=9, + range: 3..=10, }; static WORD_DIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DIA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DIA_CHILDREN), value: None, }; -pub static WORD_DIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("betees"), - dictgen::InsensitiveStr::Ascii("bets"), - dictgen::InsensitiveStr::Ascii("blical"), - dictgen::InsensitiveStr::Ascii("ganol"), - dictgen::InsensitiveStr::Ascii("gnoal"), - dictgen::InsensitiveStr::Ascii("gnoes"), - dictgen::InsensitiveStr::Ascii("gnosi"), - dictgen::InsensitiveStr::Ascii("gnosied"), - dictgen::InsensitiveStr::Ascii("gnosies"), - dictgen::InsensitiveStr::Ascii("gnositc"), - dictgen::InsensitiveStr::Ascii("gnositcs"), - dictgen::InsensitiveStr::Ascii("gnositic"), - dictgen::InsensitiveStr::Ascii("gnossed"), - dictgen::InsensitiveStr::Ascii("gnosted"), - dictgen::InsensitiveStr::Ascii("gnotics"), - dictgen::InsensitiveStr::Ascii("gonaal"), - dictgen::InsensitiveStr::Ascii("gonse"), - dictgen::InsensitiveStr::Ascii("gonsed"), - dictgen::InsensitiveStr::Ascii("gonsis"), - dictgen::InsensitiveStr::Ascii("gonstic"), - dictgen::InsensitiveStr::Ascii("gonstics"), - dictgen::InsensitiveStr::Ascii("gramas"), - dictgen::InsensitiveStr::Ascii("gramms"), - dictgen::InsensitiveStr::Ascii("hrrea"), - dictgen::InsensitiveStr::Ascii("lecs"), - dictgen::InsensitiveStr::Ascii("lectes"), - dictgen::InsensitiveStr::Ascii("lectos"), - dictgen::InsensitiveStr::Ascii("letcs"), - dictgen::InsensitiveStr::Ascii("lgoue"), - dictgen::InsensitiveStr::Ascii("loge"), - dictgen::InsensitiveStr::Ascii("louge"), - dictgen::InsensitiveStr::Ascii("mons"), - dictgen::InsensitiveStr::Ascii("rreah"), - dictgen::InsensitiveStr::Ascii("rreha"), - dictgen::InsensitiveStr::Ascii("rrheoa"), - dictgen::InsensitiveStr::Ascii("sble"), - dictgen::InsensitiveStr::Ascii("sbling"), - dictgen::InsensitiveStr::Ascii("sspointed"), + 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("bling"), + dictgen::InsensitiveStr::Ascii("pra"), + dictgen::InsensitiveStr::Ascii("spointed"), + dictgen::InsensitiveStr::Ascii("ter"), + ], + values: &[ + &["disable"], + &["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"], + &["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"), + ], + values: &[&["diagnose"], &["diagnostic"]], + range: 4..=5, +}; + +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"), + ], + values: &[&["diameter"], &["diameters"], &["diamond"], &["diamonds"]], + 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"), + ], + values: &[ + &["dialog"], + &["dilate"], + &["dialects"], + &["dialects"], + &["dialects"], + &["dialects"], + &["dialog"], + &["dialogs"], + &["dialogue"], + &["dialog"], + &["dialogs"], + &["dialogue", "dialog"], + &["dialogue"], + ], + 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("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("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: &[ - &["diabetes"], - &["diabetes"], - &["diabolical"], &["diagonal"], + &["diagnostic"], &["diagonal"], &["diagnose"], + &["diagonal"], &["diagnostic"], + &["diagnostics"], &["diagnose"], &["diagnosis"], &["diagnostic"], @@ -66211,31 +124845,99 @@ pub static WORD_DIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["diagnose"], &["diagnose"], &["diagnostic"], + &["diagnostic", "diagnostics"], &["diagonal"], + &["diagonal"], + &["diagonals"], &["diagnose"], &["diagnosed"], &["diagnosis"], &["diagnostic"], &["diagnostic"], &["diagrams"], + &["diagram"], &["diagrams"], - &["diarrhea"], - &["dialects"], - &["dialects"], - &["dialects"], - &["dialects"], - &["dialogue"], - &["dialogue"], - &["dialogue"], - &["diamonds"], - &["diarrhea"], - &["diarrhea"], - &["diarrhea"], - &["disable"], - &["disabling"], - &["disappointed"], ], - range: 4..=9, + 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 { @@ -66248,7 +124950,7 @@ static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_DEB_NODE), Some(&WORD_DEC_NODE), Some(&WORD_DED_NODE), - None, + Some(&WORD_DEE_NODE), Some(&WORD_DEF_NODE), Some(&WORD_DEG_NODE), Some(&WORD_DEH_NODE), @@ -66260,13 +124962,13 @@ static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_DEN_NODE), Some(&WORD_DEO_NODE), Some(&WORD_DEP_NODE), - None, + Some(&WORD_DEQ_NODE), Some(&WORD_DER_NODE), Some(&WORD_DES_NODE), Some(&WORD_DET_NODE), Some(&WORD_DEU_NODE), Some(&WORD_DEV_NODE), - None, + Some(&WORD_DEW_NODE), None, Some(&WORD_DEY_NODE), Some(&WORD_DEZ_NODE), @@ -66278,9 +124980,21 @@ static WORD_DEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_DEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("entralized")], - values: &[&["decentralized"]], - range: 10..=10, + keys: &[ + dictgen::InsensitiveStr::Ascii("entralized"), + dictgen::InsensitiveStr::Ascii("ert"), + dictgen::InsensitiveStr::Ascii("ibel"), + dictgen::InsensitiveStr::Ascii("ine"), + dictgen::InsensitiveStr::Ascii("inens"), + ], + values: &[ + &["decentralized"], + &["dessert"], + &["decibel"], + &["design"], + &["denizens"], + ], + range: 3..=10, }; static WORD_DEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66297,61 +125011,362 @@ pub static WORD_DEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 7..=8, }; -static WORD_DEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DEV_CHILDREN), +static WORD_DEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_DEW_CHILDREN), value: None, }; -pub static WORD_DEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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("aint"), - dictgen::InsensitiveStr::Ascii("aite"), - dictgen::InsensitiveStr::Ascii("astaded"), - dictgen::InsensitiveStr::Ascii("astaing"), - dictgen::InsensitiveStr::Ascii("astanti"), - dictgen::InsensitiveStr::Ascii("asted"), - dictgen::InsensitiveStr::Ascii("asteted"), - dictgen::InsensitiveStr::Ascii("elepmont"), - dictgen::InsensitiveStr::Ascii("elepors"), - dictgen::InsensitiveStr::Ascii("eloeprs"), - dictgen::InsensitiveStr::Ascii("elompent"), - dictgen::InsensitiveStr::Ascii("elope"), - dictgen::InsensitiveStr::Ascii("elopement"), - dictgen::InsensitiveStr::Ascii("elopemnt"), - dictgen::InsensitiveStr::Ascii("elopmant"), - dictgen::InsensitiveStr::Ascii("elopmenet"), - dictgen::InsensitiveStr::Ascii("elopmently"), - dictgen::InsensitiveStr::Ascii("elopmentwise"), - dictgen::InsensitiveStr::Ascii("elopmet"), - dictgen::InsensitiveStr::Ascii("elopmetn"), - dictgen::InsensitiveStr::Ascii("elopmnet"), - dictgen::InsensitiveStr::Ascii("elopors"), - dictgen::InsensitiveStr::Ascii("elopped"), - dictgen::InsensitiveStr::Ascii("eloppers"), - dictgen::InsensitiveStr::Ascii("elopres"), - dictgen::InsensitiveStr::Ascii("eloprs"), - dictgen::InsensitiveStr::Ascii("elpment"), - dictgen::InsensitiveStr::Ascii("elpoment"), - dictgen::InsensitiveStr::Ascii("elpoments"), - dictgen::InsensitiveStr::Ascii("els"), - dictgen::InsensitiveStr::Ascii("eolpment"), - dictgen::InsensitiveStr::Ascii("eploment"), - dictgen::InsensitiveStr::Ascii("estated"), - dictgen::InsensitiveStr::Ascii("estating"), - dictgen::InsensitiveStr::Ascii("ialet"), - dictgen::InsensitiveStr::Ascii("iatie"), - dictgen::InsensitiveStr::Ascii("ide"), - dictgen::InsensitiveStr::Ascii("ided"), - dictgen::InsensitiveStr::Ascii("ilers"), - dictgen::InsensitiveStr::Ascii("istating"), - dictgen::InsensitiveStr::Ascii("love"), - dictgen::InsensitiveStr::Ascii("loved"), - dictgen::InsensitiveStr::Ascii("olopement"), - dictgen::InsensitiveStr::Ascii("olopments"), - dictgen::InsensitiveStr::Ascii("olvendo"), - dictgen::InsensitiveStr::Ascii("otin"), - dictgen::InsensitiveStr::Ascii("ovle"), - dictgen::InsensitiveStr::Ascii("ovled"), + 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("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"], + &["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("lers"), + dictgen::InsensitiveStr::Ascii("ned"), + dictgen::InsensitiveStr::Ascii("red"), + 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("sion"), + dictgen::InsensitiveStr::Ascii("stating"), + dictgen::InsensitiveStr::Ascii("ve"), + ], + values: &[ + &["deviate"], + &["deviate"], + &["device"], + &["device"], + &["devices"], + &["device"], + &["devicecoordinates"], + &["deviceremovable"], + &["devices"], + &["devices"], + &["devices"], + &["divide"], + &["divided"], + &["divider"], + &["dividers"], + &["divides"], + &["dividing"], + &["device"], + &["device"], + &["delivers"], + &["defined"], + &["derived"], + &["devirtualisation"], + &["devirtualisation"], + &["devirtualization"], + &["devirtualization"], + &["devirtualisation"], + &["devirtualise"], + &["devirtualised"], + &["devirtualization"], + &["devirtualize"], + &["devirtualized"], + &["division"], + &["devastating"], + &["device"], + ], + range: 1..=14, +}; + +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("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("lopmnet"), + 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("loppment"), + dictgen::InsensitiveStr::Ascii("lopres"), + dictgen::InsensitiveStr::Ascii("loprs"), + dictgen::InsensitiveStr::Ascii("lpment"), + dictgen::InsensitiveStr::Ascii("lpoment"), + dictgen::InsensitiveStr::Ascii("lpoments"), + 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"], + &["development"], + &["developments"], + &["developments", "development"], + &["developmental"], + &["developments"], + &["develop"], + &["development"], + &["developments"], + &["developments"], + &["developmental"], + &["development"], + &["development"], + &["developments"], + &["developmental"], + &["developments"], + &["developments"], + &["developments"], + &["developments"], + &["developments"], + &["develops"], + &["develop"], + &["develop"], + &["developed"], + &["development"], + &["developer"], + &["developers"], + &["development"], + &["develops"], + &["develops"], + &["development"], + &["developments"], + &["developments"], + &["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"), + ], + values: &[&["device"], &["decent"], &["device"]], + 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"], @@ -66361,49 +125376,9 @@ pub static WORD_DEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["devastating"], &["devastated"], &["devastated"], - &["developments"], - &["developers"], - &["developers"], - &["developments"], - &["develop"], - &["development"], - &["developments"], - &["developmental"], - &["developments"], - &["developmental"], - &["developments"], - &["developments"], - &["developments"], - &["developments"], - &["develops"], - &["developed"], - &["developers"], - &["develops"], - &["develops"], - &["development"], - &["developments"], - &["developments"], - &["delves"], - &["developments"], - &["developments"], - &["devastated"], - &["devastating"], - &["deviate"], - &["deviate"], - &["divide"], - &["divided"], - &["delivers"], - &["devastating"], - &["devolve"], - &["devolved"], - &["development"], - &["developments"], - &["devolved"], - &["devotion"], - &["devolve"], - &["devolved"], + &["deviation"], ], - range: 3..=12, + range: 3..=6, }; static WORD_DEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66413,6 +125388,10 @@ static WORD_DEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -66422,6 +125401,10 @@ pub static WORD_DEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tshcland"), ], values: &[ + &["debug"], + &["debugging"], + &["debug"], + &["debugging"], &["dueling"], &["deutschland"], &["deutschland"], @@ -66430,122 +125413,440 @@ pub static WORD_DEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["deutschland"], &["deutschland"], ], - range: 4..=8, + range: 1..=8, }; static WORD_DET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DET_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DET_CHILDREN), value: None, }; -pub static WORD_DET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aild"), - dictgen::InsensitiveStr::Ascii("ailled"), - dictgen::InsensitiveStr::Ascii("alied"), - dictgen::InsensitiveStr::Ascii("atched"), - dictgen::InsensitiveStr::Ascii("ectarlo"), - dictgen::InsensitiveStr::Ascii("ectaron"), - dictgen::InsensitiveStr::Ascii("ectas"), - dictgen::InsensitiveStr::Ascii("ectes"), - dictgen::InsensitiveStr::Ascii("ectie"), - dictgen::InsensitiveStr::Ascii("ectivs"), - dictgen::InsensitiveStr::Ascii("ectoare"), - dictgen::InsensitiveStr::Ascii("eoriated"), - dictgen::InsensitiveStr::Ascii("eriate"), - dictgen::InsensitiveStr::Ascii("erioriating"), - dictgen::InsensitiveStr::Ascii("ermanism"), - dictgen::InsensitiveStr::Ascii("ermen"), - dictgen::InsensitiveStr::Ascii("ermenation"), - dictgen::InsensitiveStr::Ascii("ermening"), - dictgen::InsensitiveStr::Ascii("ermenism"), - dictgen::InsensitiveStr::Ascii("erminacion"), - dictgen::InsensitiveStr::Ascii("erminanti"), - dictgen::InsensitiveStr::Ascii("erminare"), - dictgen::InsensitiveStr::Ascii("erminas"), - dictgen::InsensitiveStr::Ascii("erminato"), - dictgen::InsensitiveStr::Ascii("erminaton"), - dictgen::InsensitiveStr::Ascii("erminded"), - dictgen::InsensitiveStr::Ascii("erming"), - dictgen::InsensitiveStr::Ascii("erminging"), - dictgen::InsensitiveStr::Ascii("erminig"), - dictgen::InsensitiveStr::Ascii("erminining"), - dictgen::InsensitiveStr::Ascii("erminisic"), - dictgen::InsensitiveStr::Ascii("erminisim"), - dictgen::InsensitiveStr::Ascii("erminisitc"), - dictgen::InsensitiveStr::Ascii("erminisitic"), - dictgen::InsensitiveStr::Ascii("erministc"), - dictgen::InsensitiveStr::Ascii("erministisch"), - dictgen::InsensitiveStr::Ascii("erministische"), - dictgen::InsensitiveStr::Ascii("erminitic"), - dictgen::InsensitiveStr::Ascii("ermins"), - dictgen::InsensitiveStr::Ascii("erminsim"), - dictgen::InsensitiveStr::Ascii("erminsitic"), - dictgen::InsensitiveStr::Ascii("erminsm"), - dictgen::InsensitiveStr::Ascii("ials"), - dictgen::InsensitiveStr::Ascii("matologist"), - dictgen::InsensitiveStr::Ascii("orit"), - dictgen::InsensitiveStr::Ascii("ramental"), - dictgen::InsensitiveStr::Ascii("remental"), - dictgen::InsensitiveStr::Ascii("rimential"), - dictgen::InsensitiveStr::Ascii("rimentul"), - dictgen::InsensitiveStr::Ascii("riot"), - dictgen::InsensitiveStr::Ascii("uschland"), + 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("aching"), + ], + values: &[&["detach"], &["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("mine"), + dictgen::InsensitiveStr::Ascii("oy"), + dictgen::InsensitiveStr::Ascii("oyed"), + dictgen::InsensitiveStr::Ascii("oying"), + dictgen::InsensitiveStr::Ascii("oys"), + dictgen::InsensitiveStr::Ascii("ucted"), ], values: &[ - &["detailed"], - &["detailed"], - &["detailed"], - &["detached"], - &["detector"], - &["detector"], - &["detects"], - &["detects"], - &["detectives"], - &["detectives"], - &["detector"], - &["deteriorated"], - &["deteriorate"], - &["deteriorating"], - &["determinism"], - &["determines"], - &["determination"], - &["determining"], - &["determinism"], - &["determination"], - &["determination"], - &["determine"], - &["determines"], - &["determination"], - &["determination"], - &["determine"], - &["determining"], - &["determining"], - &["determining"], - &["determining"], - &["deterministic"], - &["determinism"], - &["deterministic"], - &["deterministic"], - &["deterministic"], - &["deterministic"], - &["deterministic"], - &["deterministic"], - &["determines"], - &["determinism"], - &["deterministic"], - &["determinism"], - &["details"], - &["dermatologist"], - &["detroit"], &["detrimental"], &["detrimental"], + &["determining"], &["detrimental"], &["detrimental"], &["detroit"], - &["deutschland"], + &["determine"], + &["destroy"], + &["destroyed"], + &["destroying"], + &["destroys"], + &["destructed"], ], - range: 4..=13, + 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("als"), + dictgen::InsensitiveStr::Ascii("nation"), + ], + values: &[&["details"], &["destination"]], + range: 3..=6, +}; + +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("mine"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[ + &["detected", "deleted"], + &["deletes", "detects"], + &["detecting", "deleting"], + &["detection", "deletion"], + &["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("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("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("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("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("mnine"), + dictgen::InsensitiveStr::Ascii("nine"), + ], + values: &[ + &["deterrent"], + &["determine"], + &["determined"], + &["deteriorate"], + &["determined"], + &["determine"], + &["deteriorating"], + &["determine"], + &["determinism"], + &["determines"], + &["determinant"], + &["determination"], + &["determining"], + &["determinism"], + &["deterministic"], + &["determines"], + &["determine"], + &["determination"], + &["determination"], + &["determine"], + &["determines"], + &["determined"], + &["determination"], + &["determination"], + &["determined"], + &["determine", "determined"], + &["determine"], + &["determining"], + &["determining", "determine"], + &["determining"], + &["determining"], + &["determining"], + &["deterministic"], + &["determinism"], + &["deterministic"], + &["deterministic"], + &["deterministic"], + &["deterministic"], + &["deterministic"], + &["deterministic"], + &["deterministic"], + &["determine"], + &["determines"], + &["determinism"], + &["deterministic"], + &["determinism"], + &["deterministic"], + &["deterministically"], + &["determine", "determined"], + &["determines"], + &["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("ing"), + 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("tivs"), + dictgen::InsensitiveStr::Ascii("toare"), + dictgen::InsensitiveStr::Ascii("tsion"), + ], + values: &[ + &["detected"], + &["detecting"], + &["detects", "deters", "detect"], + &["detector"], + &["detector"], + &["detects"], + &["detected", "detect", "detects"], + &["detected"], + &["detects"], + &["detected"], + &["detectives"], + &["detection"], + &["detectives"], + &["detector"], + &["detection"], + ], + 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("tion")], + values: &[&["detection"]], + range: 4..=4, +}; + +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("tch"), + dictgen::InsensitiveStr::Ascii("tched"), + dictgen::InsensitiveStr::Ascii("tches"), + dictgen::InsensitiveStr::Ascii("tching"), + ], + values: &[ + &["database"], + &["detaches"], + &["detached"], + &["detailed"], + &["detailed"], + &["details"], + &["detailed"], + &["detach"], + &["detached"], + &["detaches"], + &["detaching"], + ], + range: 2..=6, }; static WORD_DES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66554,7 +125855,7 @@ static WORD_DES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_DESA_NODE), None, Some(&WORD_DESC_NODE), None, @@ -66565,7 +125866,7 @@ static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_DESI_NODE), None, Some(&WORD_DESK_NODE), - None, + Some(&WORD_DESL_NODE), None, Some(&WORD_DESN_NODE), Some(&WORD_DESO_NODE), @@ -66578,10 +125879,24 @@ static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, 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, @@ -66594,100 +125909,261 @@ pub static WORD_DESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_DEST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DEST_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DEST_CHILDREN), value: None, }; -pub static WORD_DEST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ablized"), - dictgen::InsensitiveStr::Ascii("iantion"), - dictgen::InsensitiveStr::Ascii("iantions"), - dictgen::InsensitiveStr::Ascii("inaiton"), - dictgen::InsensitiveStr::Ascii("inatin"), - dictgen::InsensitiveStr::Ascii("inationhash"), - dictgen::InsensitiveStr::Ascii("inato"), - dictgen::InsensitiveStr::Ascii("inaton"), - dictgen::InsensitiveStr::Ascii("inatons"), - dictgen::InsensitiveStr::Ascii("inction"), - dictgen::InsensitiveStr::Ascii("inctions"), - dictgen::InsensitiveStr::Ascii("iney"), - dictgen::InsensitiveStr::Ascii("inty"), - dictgen::InsensitiveStr::Ascii("kop"), - dictgen::InsensitiveStr::Ascii("kops"), - dictgen::InsensitiveStr::Ascii("ory"), - dictgen::InsensitiveStr::Ascii("oryed"), - dictgen::InsensitiveStr::Ascii("oryer"), - dictgen::InsensitiveStr::Ascii("oryers"), - dictgen::InsensitiveStr::Ascii("orying"), - dictgen::InsensitiveStr::Ascii("orys"), - dictgen::InsensitiveStr::Ascii("raction"), - dictgen::InsensitiveStr::Ascii("ractions"), - dictgen::InsensitiveStr::Ascii("ributors"), - dictgen::InsensitiveStr::Ascii("ros"), - dictgen::InsensitiveStr::Ascii("rose"), - dictgen::InsensitiveStr::Ascii("royd"), - dictgen::InsensitiveStr::Ascii("royeds"), - dictgen::InsensitiveStr::Ascii("royeer"), - dictgen::InsensitiveStr::Ascii("royes"), - dictgen::InsensitiveStr::Ascii("royr"), - dictgen::InsensitiveStr::Ascii("ruccion"), - dictgen::InsensitiveStr::Ascii("rucion"), - dictgen::InsensitiveStr::Ascii("ruciton"), - dictgen::InsensitiveStr::Ascii("rucive"), - dictgen::InsensitiveStr::Ascii("ructivo"), - dictgen::InsensitiveStr::Ascii("ructo"), - dictgen::InsensitiveStr::Ascii("ruktion"), - dictgen::InsensitiveStr::Ascii("ruktive"), - dictgen::InsensitiveStr::Ascii("ryoed"), - dictgen::InsensitiveStr::Ascii("ryoer"), - dictgen::InsensitiveStr::Ascii("ryoing"), + dictgen::InsensitiveStr::Ascii("ction"), + dictgen::InsensitiveStr::Ascii("ctive"), + dictgen::InsensitiveStr::Ascii("rcted"), + dictgen::InsensitiveStr::Ascii("rtor"), + dictgen::InsensitiveStr::Ascii("rtors"), ], values: &[ - &["destabilized"], - &["destinations"], - &["destinations"], - &["destinations"], - &["destinations"], - &["destinations"], - &["destination"], - &["destination"], - &["destinations"], - &["destination"], - &["destinations"], - &["destiny"], - &["destiny"], - &["desktop"], - &["desktops"], + &["destruction"], + &["destructive"], + &["destructed"], + &["destructor"], + &["destructors"], + ], + range: 4..=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("uktion"), + dictgen::InsensitiveStr::Ascii("uktive"), + 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"], + &["destroyers"], + &["destroyers"], + &["destroys"], + &["destroyers"], + &["destruction"], + &["destruction"], + &["destruction"], + &["destructive"], + &["destruction"], + &["destruction"], + &["destruction"], + &["destructive"], + &["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("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("yed"), + ], + values: &[ + &["destroyed"], + &["distort"], &["destroy"], &["destroyed"], &["destroyer"], &["destroyers"], &["destroying"], &["destroys"], - &["destruction"], - &["distractions"], - &["distributors"], - &["destroys"], - &["destroyers"], &["destroyed"], - &["destroyers"], - &["destroyers"], - &["destroys"], - &["destroyers"], - &["destruction"], - &["destruction"], - &["destruction"], - &["destructive"], - &["destruction"], - &["destruction"], - &["destruction"], - &["destructive"], - &["destroyed"], - &["destroyer"], - &["destroying"], ], - range: 3..=11, + range: 2..=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("naiton"), + dictgen::InsensitiveStr::Ascii("narion"), + dictgen::InsensitiveStr::Ascii("nataion"), + dictgen::InsensitiveStr::Ascii("nataions"), + dictgen::InsensitiveStr::Ascii("natin"), + 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("nty"), + dictgen::InsensitiveStr::Ascii("onation"), + dictgen::InsensitiveStr::Ascii("onations"), + ], + values: &[ + &["destinations", "destination"], + &["destinations"], + &["destinations"], + &["destination"], + &["destination"], + &["destinations"], + &["destinations", "destination"], + &["destinations"], + &["destination"], + &["destination"], + &["destinations"], + &["destination"], + &["destinations"], + &["destiny"], + &["distinguish"], + &["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"), + ], + values: &[&["destabilized"], &["destination"]], + range: 6..=6, }; static WORD_DESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66697,11 +126173,23 @@ static WORD_DESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cribe"), + dictgen::InsensitiveStr::Ascii("cribing"), dictgen::InsensitiveStr::Ascii("ertation"), + dictgen::InsensitiveStr::Ascii("icate"), dictgen::InsensitiveStr::Ascii("icated"), + dictgen::InsensitiveStr::Ascii("ication"), dictgen::InsensitiveStr::Ascii("igned"), ], - values: &[&["dissertation"], &["desiccated"], &["designed"]], + values: &[ + &["describe"], + &["describing"], + &["dissertation"], + &["desiccate"], + &["desiccated"], + &["desiccation"], + &["designed"], + ], range: 5..=8, }; @@ -66714,9 +126202,34 @@ pub static WORD_DESR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ 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: &[&["disregarding"], &["desirable"]], - range: 5..=8, + values: &[ + &["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 { @@ -66760,9 +126273,11 @@ pub static WORD_DESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("iration"), dictgen::InsensitiveStr::Ascii("iste"), dictgen::InsensitiveStr::Ascii("oited"), + dictgen::InsensitiveStr::Ascii("osit"), + dictgen::InsensitiveStr::Ascii("osition"), ], values: &[ - &["desperate"], + &["desperate", "disparate"], &["desperately"], &["desperation"], &["despicable"], @@ -66785,6 +126300,8 @@ pub static WORD_DESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["desperation"], &["despise"], &["deposited"], + &["deposit", "deposition"], + &["disposition"], ], range: 3..=8, }; @@ -66796,12 +126313,28 @@ static WORD_DESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["desmond"], &["disorder"], &["disoriented"]], - range: 3..=7, + values: &[ + &["design"], + &["designed"], + &["designer"], + &["designing"], + &["designs"], + &["dissolve"], + &["desmond"], + &["disorder"], + &["disoriented"], + ], + range: 2..=7, }; static WORD_DESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66811,11 +126344,29 @@ static WORD_DESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["densely"], &["density"]], - range: 3..=3, + values: &[&["dense"], &["densely"], &["density"], &["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 { @@ -66825,12 +126376,22 @@ static WORD_DESK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["desktops"]], - range: 4..=6, + values: &[ + &["desktop"], + &["desktops"], + &["desktop"], + &["desktops"], + &["desktops"], + &["disguise"], + ], + range: 2..=6, }; static WORD_DESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66840,66 +126401,118 @@ static WORD_DESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ntation"), + dictgen::InsensitiveStr::Ascii("ntations"), dictgen::InsensitiveStr::Ascii("ntegrated"), dictgen::InsensitiveStr::Ascii("ntegration"), dictgen::InsensitiveStr::Ascii("nterested"), + dictgen::InsensitiveStr::Ascii("pite"), dictgen::InsensitiveStr::Ascii("reable"), + dictgen::InsensitiveStr::Ascii("sion"), + dictgen::InsensitiveStr::Ascii("sions"), + dictgen::InsensitiveStr::Ascii("tination"), + 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"], + &["destination"], + &["destinations"], &["disintegrated"], &["disintegration"], &["disinterested"], + &["despite"], &["desirable"], + &["decision"], + &["decisions"], + &["destination"], + &["decision"], + &["decisions"], &["destination"], &["destinations"], &["destined"], &["destiny"], ], - range: 2..=10, + range: 1..=10, }; static WORD_DESG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66909,6 +126522,7 @@ static WORD_DESG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -66920,6 +126534,7 @@ pub static WORD_DESG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ustingly"), ], values: &[ + &["design"], &["designated"], &["designation"], &["destinations"], @@ -66930,7 +126545,7 @@ pub static WORD_DESG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["designs"], &["disgustingly"], ], - range: 3..=8, + range: 2..=8, }; static WORD_DESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -66950,6 +126565,9 @@ pub static WORD_DESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ntitized"), dictgen::InsensitiveStr::Ascii("ntizised"), dictgen::InsensitiveStr::Ascii("ntralized"), + dictgen::InsensitiveStr::Ascii("pears"), + dictgen::InsensitiveStr::Ascii("railize"), + dictgen::InsensitiveStr::Ascii("rializazion"), ], values: &[ &["desensitized"], @@ -66962,168 +126580,881 @@ pub static WORD_DESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["desensitized"], &["desensitised"], &["decentralized"], + &["disappears"], + &["deserialize"], + &["deserialization"], ], - range: 7..=9, + range: 5..=11, }; static WORD_DESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DESC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DESC_CHILDREN), value: None, }; -pub static WORD_DESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("andants"), - dictgen::InsensitiveStr::Ascii("endands"), - dictgen::InsensitiveStr::Ascii("endats"), - dictgen::InsensitiveStr::Ascii("endend"), - dictgen::InsensitiveStr::Ascii("endends"), - dictgen::InsensitiveStr::Ascii("endenta"), - dictgen::InsensitiveStr::Ascii("ened"), - dictgen::InsensitiveStr::Ascii("entants"), - dictgen::InsensitiveStr::Ascii("enting"), - dictgen::InsensitiveStr::Ascii("erning"), - dictgen::InsensitiveStr::Ascii("ibed"), - dictgen::InsensitiveStr::Ascii("ipable"), - dictgen::InsensitiveStr::Ascii("irbe"), - dictgen::InsensitiveStr::Ascii("irbes"), - dictgen::InsensitiveStr::Ascii("irption"), - dictgen::InsensitiveStr::Ascii("ision"), - dictgen::InsensitiveStr::Ascii("isions"), - dictgen::InsensitiveStr::Ascii("prition"), - dictgen::InsensitiveStr::Ascii("ribiste"), - dictgen::InsensitiveStr::Ascii("ribtion"), - dictgen::InsensitiveStr::Ascii("ribtions"), - dictgen::InsensitiveStr::Ascii("rie"), - dictgen::InsensitiveStr::Ascii("riibes"), - dictgen::InsensitiveStr::Ascii("riminant"), - dictgen::InsensitiveStr::Ascii("ripcion"), - dictgen::InsensitiveStr::Ascii("ripiton"), - dictgen::InsensitiveStr::Ascii("ripters"), - dictgen::InsensitiveStr::Ascii("riptivos"), - dictgen::InsensitiveStr::Ascii("riptoin"), - dictgen::InsensitiveStr::Ascii("ripton"), - dictgen::InsensitiveStr::Ascii("riptons"), - dictgen::InsensitiveStr::Ascii("rise"), - dictgen::InsensitiveStr::Ascii("ritpion"), - dictgen::InsensitiveStr::Ascii("rpition"), - dictgen::InsensitiveStr::Ascii("tiptions"), - dictgen::InsensitiveStr::Ascii("truction"), - dictgen::InsensitiveStr::Ascii("uss"), + 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"), + ], + values: &[ + &["description"], + &["descriptions"], + &["descriptor"], + &["descriptors"], + &["desktop"], + &["destructed"], + &["destruction"], + &["destructive"], + &["destructor"], + ], + 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, + None, + 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: &[ - &["descendants"], - &["descendants"], - &["descendants"], - &["descended"], - &["descended"], - &["descendents"], - &["descend"], - &["descendants"], - &["descending"], - &["descending"], - &["described"], - &["despicable"], &["describe"], - &["describes"], + &["describing"], + &["description"], &["descriptions"], - &["decision"], - &["decisions"], + ], + 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_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::Flat(&WORD_DESCRI_CHILDREN), + value: None, +}; + +pub static WORD_DESCRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("b"), + dictgen::InsensitiveStr::Ascii("bibg"), + dictgen::InsensitiveStr::Ascii("biste"), + dictgen::InsensitiveStr::Ascii("bng"), + dictgen::InsensitiveStr::Ascii("btion"), + dictgen::InsensitiveStr::Ascii("btions"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("ibes"), + dictgen::InsensitiveStr::Ascii("minant"), + dictgen::InsensitiveStr::Ascii("minate"), + dictgen::InsensitiveStr::Ascii("minated"), + dictgen::InsensitiveStr::Ascii("minates"), + dictgen::InsensitiveStr::Ascii("minating"), + dictgen::InsensitiveStr::Ascii("ont"), + dictgen::InsensitiveStr::Ascii("otor"), + dictgen::InsensitiveStr::Ascii("pcion"), + dictgen::InsensitiveStr::Ascii("pe"), + dictgen::InsensitiveStr::Ascii("ped"), + dictgen::InsensitiveStr::Ascii("pes"), + dictgen::InsensitiveStr::Ascii("ping"), + dictgen::InsensitiveStr::Ascii("pition"), + dictgen::InsensitiveStr::Ascii("piton"), + dictgen::InsensitiveStr::Ascii("por"), + dictgen::InsensitiveStr::Ascii("pters"), + dictgen::InsensitiveStr::Ascii("ptio"), + dictgen::InsensitiveStr::Ascii("ptiom"), + dictgen::InsensitiveStr::Ascii("ptionm"), + dictgen::InsensitiveStr::Ascii("ptior"), + dictgen::InsensitiveStr::Ascii("ptiors"), + dictgen::InsensitiveStr::Ascii("ptivos"), + dictgen::InsensitiveStr::Ascii("pto"), + dictgen::InsensitiveStr::Ascii("ptoin"), + dictgen::InsensitiveStr::Ascii("ptoins"), + dictgen::InsensitiveStr::Ascii("pton"), + dictgen::InsensitiveStr::Ascii("ptons"), + dictgen::InsensitiveStr::Ascii("ptot"), + dictgen::InsensitiveStr::Ascii("ptoy"), + dictgen::InsensitiveStr::Ascii("ptuve"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tpion"), + dictgen::InsensitiveStr::Ascii("tpions"), + dictgen::InsensitiveStr::Ascii("tpiton"), + dictgen::InsensitiveStr::Ascii("tpitons"), + dictgen::InsensitiveStr::Ascii("tpor"), + dictgen::InsensitiveStr::Ascii("tpors"), + dictgen::InsensitiveStr::Ascii("tpr"), + dictgen::InsensitiveStr::Ascii("tpro"), + dictgen::InsensitiveStr::Ascii("tpros"), + dictgen::InsensitiveStr::Ascii("tprs"), + dictgen::InsensitiveStr::Ascii("tption"), + dictgen::InsensitiveStr::Ascii("tptions"), + dictgen::InsensitiveStr::Ascii("tptive"), + dictgen::InsensitiveStr::Ascii("tptor"), + dictgen::InsensitiveStr::Ascii("tptors"), + ], + values: &[ + &["describe"], + &["describing"], &["describes"], + &["describing"], &["description"], &["descriptions"], &["describe"], &["describes"], &["discriminant"], + &["discriminate"], + &["discriminated"], + &["discriminates"], + &["discriminating"], + &["description"], + &["descriptor"], + &["description"], + &["describe"], + &["described"], + &["describes"], + &["describing"], &["description"], &["descriptions"], + &["descriptor"], + &["descriptors"], + &["description"], + &["description"], + &["description"], + &["descriptor"], &["descriptors"], &["descriptions"], + &["descriptor"], + &["descriptions", "description"], &["descriptions"], &["description"], &["descriptions"], + &["descriptor"], + &["descriptor"], + &["descriptive"], &["describes"], + &["description"], + &["descriptions", "description"], &["descriptions"], + &["description"], &["descriptions"], + &["descriptor"], + &["descriptors"], + &["descriptor"], + &["descriptor"], + &["descriptors"], + &["descriptors"], + &["description"], &["descriptions"], - &["destruction"], - &["discuss"], + &["descriptive"], + &["descriptor"], + &["descriptors"], ], - range: 3..=8, + range: 1..=8, }; -static WORD_DER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DER_CHILDREN), +static WORD_DESCRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_DESCRE_CHILDREN), value: None, }; -pub static WORD_DER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_DESCRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("menting")], + values: &[&["decrementing"]], + range: 7..=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("agotory"), - dictgen::InsensitiveStr::Ascii("am"), - dictgen::InsensitiveStr::Ascii("egualtion"), - dictgen::InsensitiveStr::Ascii("egulaiton"), - dictgen::InsensitiveStr::Ascii("egulatin"), - dictgen::InsensitiveStr::Ascii("ivate"), - dictgen::InsensitiveStr::Ascii("ivaties"), - dictgen::InsensitiveStr::Ascii("ivativos"), - dictgen::InsensitiveStr::Ascii("iviated"), - dictgen::InsensitiveStr::Ascii("ivitave"), - dictgen::InsensitiveStr::Ascii("ivitaves"), - dictgen::InsensitiveStr::Ascii("ivitive"), - dictgen::InsensitiveStr::Ascii("ivitives"), - dictgen::InsensitiveStr::Ascii("matalogist"), - dictgen::InsensitiveStr::Ascii("matolagist"), - dictgen::InsensitiveStr::Ascii("matoligist"), - dictgen::InsensitiveStr::Ascii("matologyst"), - dictgen::InsensitiveStr::Ascii("metologist"), - dictgen::InsensitiveStr::Ascii("mitologist"), - dictgen::InsensitiveStr::Ascii("ogatary"), - dictgen::InsensitiveStr::Ascii("ogatery"), - dictgen::InsensitiveStr::Ascii("ogetory"), - dictgen::InsensitiveStr::Ascii("ogitory"), - dictgen::InsensitiveStr::Ascii("ogotary"), - dictgen::InsensitiveStr::Ascii("ogotory"), - dictgen::InsensitiveStr::Ascii("patologist"), - dictgen::InsensitiveStr::Ascii("pivation"), - dictgen::InsensitiveStr::Ascii("ugulation"), - dictgen::InsensitiveStr::Ascii("viative"), - dictgen::InsensitiveStr::Ascii("viatives"), + 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("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"], + &["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("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"], + &["descendants"], + &["descended", "descendent", "descendent"], + &["descended"], + &["descendents"], + &["descend"], + &["descendants"], + &["descendents", "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("ndants"), + ], + values: &[&["deallocate"], &["deallocated"], &["descendants"]], + range: 6..=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, + None, + None, +]; + +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"], - &["dram"], - &["deregulation"], - &["deregulation"], - &["deregulation"], + &["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("ines"), + dictgen::InsensitiveStr::Ascii("itologist"), + ], + values: &[ + &["dermatologist"], + &["dermatologist"], + &["dermatologist"], + &["dermatologist"], + &["dermatologist"], + &["determine"], + &["determines"], + &["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("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"], + &["derived"], + &["derivative"], + &["derivatives"], + &["derivation"], &["derivative"], &["derivatives"], &["derivatives"], + &["derive", "driver"], &["derived"], &["derivative"], &["derivatives"], &["derivative"], &["derivatives"], - &["dermatologist"], - &["dermatologist"], - &["dermatologist"], - &["dermatologist"], - &["dermatologist"], - &["dermatologist"], - &["derogatory"], - &["derogatory"], - &["derogatory"], - &["derogatory"], - &["derogatory"], - &["derogatory"], - &["dermatologist"], - &["deprivation"], + &["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("ien"), + dictgen::InsensitiveStr::Ascii("iend"), + dictgen::InsensitiveStr::Ascii("ine"), + dictgen::InsensitiveStr::Ascii("ined"), + ], + values: &[&["define"], &["defined"], &["define"], &["defined"]], + range: 3..=4, +}; + +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("ferencable"), + 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("vative"), + dictgen::InsensitiveStr::Ascii("vatives"), + ], + values: &[ + &["directive"], + &["directory"], + &["dereference"], + &["dereferenced"], + &["dereferencing"], + &["dereference"], + &["dereferenceable"], + &["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"], ], - range: 2..=10, + range: 5..=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")], + values: &[&["dequeued"]], + range: 3..=3, }; static WORD_DEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -67145,7 +127476,7 @@ static WORD_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_DEPL_NODE), None, - None, + Some(&WORD_DEPN_NODE), Some(&WORD_DEPO_NODE), None, None, @@ -67190,6 +127521,24 @@ static WORD_DEPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("acated"), + dictgen::InsensitiveStr::Ascii("eacte"), + dictgen::InsensitiveStr::Ascii("eacted"), + dictgen::InsensitiveStr::Ascii("eacts"), + 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"), @@ -67198,7 +127547,17 @@ pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -67206,6 +127565,24 @@ pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ovation"), ], values: &[ + &["deprecated"], + &["deprecate"], + &["deprecated"], + &["deprecates"], + &["deprecated"], + &["deprecate", "depreciate"], + &["deprecated", "depreciated"], + &["depreciating", "deprecating"], + &["depreciation", "deprecation"], + &["deprecated"], + &["deprecate"], + &["deprecate"], + &["deprecated"], + &["deprecates"], + &["deprecating"], + &["deprecation"], + &["deprecates"], + &["deprecated"], &["depressive"], &["depressive"], &["depressive"], @@ -67214,14 +127591,24 @@ pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["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..=7, + range: 4..=8, }; static WORD_DEPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -67235,6 +127622,8 @@ pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -67249,6 +127638,8 @@ pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["deployed"], &["deploying"], &["deployment"], + &["temporarily"], + &["deposing"], &["deposits"], &["deposited"], &["deposits"], @@ -67261,6 +127652,20 @@ pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic range: 4..=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, @@ -67269,21 +127674,33 @@ static WORD_DEPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DEPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("acements"), + 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("yoing"), dictgen::InsensitiveStr::Ascii("yoment"), ], values: &[ &["replacements"], + &["deployed"], + &["deployment"], + &["deployments"], &["deplorable"], &["deplorable"], &["deplorable"], &["deplorable"], &["deployed"], + &["deployment"], + &["deployment"], + &["deployments"], &["deploying"], &["deployment"], ], @@ -67316,62 +127733,238 @@ pub static WORD_DEPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_DEPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DEPE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DEPE_CHILDREN), value: None, }; -pub static WORD_DEPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ction"), - dictgen::InsensitiveStr::Ascii("dencies"), - dictgen::InsensitiveStr::Ascii("dency"), - dictgen::InsensitiveStr::Ascii("lted"), - dictgen::InsensitiveStr::Ascii("ncencies"), - dictgen::InsensitiveStr::Ascii("ncency"), - dictgen::InsensitiveStr::Ascii("ndancey"), - dictgen::InsensitiveStr::Ascii("ndancies"), - dictgen::InsensitiveStr::Ascii("ndancy"), - dictgen::InsensitiveStr::Ascii("ndandt"), - dictgen::InsensitiveStr::Ascii("ndat"), - dictgen::InsensitiveStr::Ascii("ndd"), - dictgen::InsensitiveStr::Ascii("ndencey"), - dictgen::InsensitiveStr::Ascii("ndencias"), - dictgen::InsensitiveStr::Ascii("ndencie"), - dictgen::InsensitiveStr::Ascii("ndends"), - dictgen::InsensitiveStr::Ascii("ndened"), - dictgen::InsensitiveStr::Ascii("ndenices"), - dictgen::InsensitiveStr::Ascii("ndenies"), - dictgen::InsensitiveStr::Ascii("ndensies"), - dictgen::InsensitiveStr::Ascii("ndenta"), - dictgen::InsensitiveStr::Ascii("ndente"), - dictgen::InsensitiveStr::Ascii("recation"), + dictgen::InsensitiveStr::Ascii("ecated"), + dictgen::InsensitiveStr::Ascii("ecation"), + ], + values: &[&["deprecated"], &["deprecation"]], + range: 6..=7, +}; + +static WORD_DEPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_DEPEN_CHILDREN), + value: None, +}; + +pub static WORD_DEPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("cencies"), + dictgen::InsensitiveStr::Ascii("cency"), + dictgen::InsensitiveStr::Ascii("cent"), + dictgen::InsensitiveStr::Ascii("cies"), + dictgen::InsensitiveStr::Ascii("cy"), + dictgen::InsensitiveStr::Ascii("dancey"), + dictgen::InsensitiveStr::Ascii("dancies"), + dictgen::InsensitiveStr::Ascii("dancy"), + dictgen::InsensitiveStr::Ascii("dancys"), + dictgen::InsensitiveStr::Ascii("dand"), + dictgen::InsensitiveStr::Ascii("dandt"), + dictgen::InsensitiveStr::Ascii("dat"), + dictgen::InsensitiveStr::Ascii("dcies"), + dictgen::InsensitiveStr::Ascii("dcy"), + dictgen::InsensitiveStr::Ascii("dd"), + dictgen::InsensitiveStr::Ascii("decies"), + dictgen::InsensitiveStr::Ascii("decy"), + dictgen::InsensitiveStr::Ascii("decys"), + dictgen::InsensitiveStr::Ascii("dees"), + dictgen::InsensitiveStr::Ascii("deing"), + dictgen::InsensitiveStr::Ascii("dencey"), + dictgen::InsensitiveStr::Ascii("dencias"), + dictgen::InsensitiveStr::Ascii("dencie"), + dictgen::InsensitiveStr::Ascii("dencied"), + dictgen::InsensitiveStr::Ascii("denciens"), + dictgen::InsensitiveStr::Ascii("dencis"), + dictgen::InsensitiveStr::Ascii("dencys"), + dictgen::InsensitiveStr::Ascii("dend"), + dictgen::InsensitiveStr::Ascii("dendent"), + dictgen::InsensitiveStr::Ascii("dends"), + dictgen::InsensitiveStr::Ascii("dened"), + dictgen::InsensitiveStr::Ascii("denices"), + dictgen::InsensitiveStr::Ascii("denies"), + dictgen::InsensitiveStr::Ascii("dening"), + dictgen::InsensitiveStr::Ascii("densies"), + dictgen::InsensitiveStr::Ascii("denta"), + dictgen::InsensitiveStr::Ascii("dente"), + dictgen::InsensitiveStr::Ascii("deny"), + dictgen::InsensitiveStr::Ascii("dices"), + dictgen::InsensitiveStr::Ascii("dicy"), + dictgen::InsensitiveStr::Ascii("dig"), + dictgen::InsensitiveStr::Ascii("dncies"), + dictgen::InsensitiveStr::Ascii("dncy"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("edecies"), + dictgen::InsensitiveStr::Ascii("edecy"), + dictgen::InsensitiveStr::Ascii("edent"), + dictgen::InsensitiveStr::Ascii("encies"), + dictgen::InsensitiveStr::Ascii("encis"), + dictgen::InsensitiveStr::Ascii("ency"), + dictgen::InsensitiveStr::Ascii("encys"), + dictgen::InsensitiveStr::Ascii("end"), + dictgen::InsensitiveStr::Ascii("endecies"), + dictgen::InsensitiveStr::Ascii("endecy"), + dictgen::InsensitiveStr::Ascii("endence"), + dictgen::InsensitiveStr::Ascii("endencies"), + dictgen::InsensitiveStr::Ascii("endency"), + dictgen::InsensitiveStr::Ascii("endent"), + dictgen::InsensitiveStr::Ascii("ending"), + dictgen::InsensitiveStr::Ascii("ent"), + dictgen::InsensitiveStr::Ascii("ently"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("nding"), ], values: &[ - &["deception"], &["dependencies"], &["dependency"], - &["depleted"], + &["dependent"], &["dependencies"], &["dependency"], &["dependency"], &["dependencies"], &["dependency"], + &["dependencies"], &["dependant"], &["dependant"], + &["dependant"], + &["dependencies"], + &["dependency"], &["depended"], + &["dependencies"], &["dependency"], &["dependencies"], - &["dependence"], + &["dependencies"], + &["depending"], + &["dependency"], + &["dependencies"], + &["dependence", "dependency"], + &["dependency"], + &["dependencies"], + &["dependencies"], + &["dependencies"], + &["dependent", "depended"], + &["dependent"], &["depended"], &["depended"], &["dependencies"], &["dependencies"], + &["depending"], &["dependencies"], &["dependent"], &["dependence"], - &["deprecation"], + &["dependency"], + &["dependencies"], + &["dependency"], + &["depending"], + &["dependencies"], + &["dependency"], + &["depend"], + &["dependencies"], + &["dependency"], + &["dependent"], + &["dependencies"], + &["dependencies"], + &["dependency"], + &["dependencies"], + &["depend"], + &["dependencies"], + &["dependency"], + &["dependence"], + &["dependencies"], + &["dependency"], + &["dependent"], + &["depending"], + &["dependent"], + &["dependently"], + &["depending", "deepening"], + &["depending"], ], - range: 3..=8, + range: 2..=9, +}; + +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("tion"), + ], + values: &[&["deprecated"], &["deception"]], + range: 4..=4, }; static WORD_DEPD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -67380,9 +127973,81 @@ static WORD_DEPD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_DEPD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ending")], - values: &[&["depending"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("en"), + dictgen::InsensitiveStr::Ascii("ence"), + 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"], + &["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 { @@ -67415,6 +128080,10 @@ static WORD_DEPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -67425,6 +128094,10 @@ pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("rtue"), ], values: &[ + &["dependance"], + &["dependencies"], + &["dependency"], + &["dependent"], &["department"], &["departmental"], &["departments"], @@ -67434,7 +128107,7 @@ pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["departments"], &["departure"], ], - range: 4..=7, + range: 4..=8, }; static WORD_DEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -67444,30 +128117,48 @@ static WORD_DEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 5..=10, + range: 2..=10, }; static WORD_DEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -67501,9 +128192,11 @@ pub static WORD_DEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tistas"), dictgen::InsensitiveStr::Ascii("tistes"), ], @@ -67533,8 +128226,10 @@ pub static WORD_DEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["denominator"], &["densely"], &["density"], + &["density"], &["densely"], &["densely"], + &["density"], &["dentists"], &["dentists"], ], @@ -67567,7 +128262,7 @@ static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_DEMS_NODE), None, - None, + Some(&WORD_DEMU_NODE), None, None, None, @@ -67575,6 +128270,17 @@ static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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, @@ -67595,7 +128301,7 @@ static WORD_DEMO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_DEMOC_NODE), - None, + Some(&WORD_DEMOD_NODE), None, None, Some(&WORD_DEMOG_NODE), @@ -67634,6 +128340,10 @@ pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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: &[ @@ -67644,9 +128354,13 @@ pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["demonstrating"], &["demonstrations"], &["demonstrations"], + &["demonstrate"], + &["demonstrated"], + &["demonstrates"], + &["demonstrating"], &["demonstration"], ], - range: 6..=9, + range: 5..=9, }; static WORD_DEMOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -67670,6 +128384,7 @@ pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -67703,6 +128418,7 @@ pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["denominations"], &["denominations"], &["denominator"], + &["denominators"], &["demolished"], &["demonstrate"], &["demonstrated"], @@ -67744,6 +128460,7 @@ pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -67758,6 +128475,7 @@ pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["demolition"], &["demolition"], &["demolition"], + &["demolition"], &["demolished"], &["demolition"], ], @@ -67766,7 +128484,7 @@ pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di static WORD_DEMOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_DEMOG_CHILDREN), - value: None, + value: Some(&["demo"]), }; pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -67774,6 +128492,7 @@ pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -67785,6 +128504,7 @@ pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["demographic"], &["demographic"], &["demographics"], + &["demographic"], &["demographics"], &["demographics"], &["demographic"], @@ -67792,7 +128512,18 @@ pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["demographic"], &["demographics"], ], - range: 5..=7, + 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 { @@ -67876,6 +128607,9 @@ pub static WORD_DEME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -67885,6 +128619,9 @@ pub static WORD_DEME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["demeanor"], &["demeanor"], + &["dimension"], + &["dimensional"], + &["dimensions"], &["demonstration"], &["demonstrations"], &["dementia"], @@ -67912,126 +128649,547 @@ static WORD_DEMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["demands"], &["demands"]], - range: 4..=4, + values: &[ + &["demand"], + &["demands"], + &["demands"], + &["demand", "demeaned"], + ], + range: 3..=4, }; static WORD_DEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DEL_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DEL_CHILDREN), value: None, }; -pub static WORD_DEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aership"), - dictgen::InsensitiveStr::Ascii("aerships"), - dictgen::InsensitiveStr::Ascii("agates"), - dictgen::InsensitiveStr::Ascii("apidated"), - dictgen::InsensitiveStr::Ascii("caration"), - dictgen::InsensitiveStr::Ascii("care"), - dictgen::InsensitiveStr::Ascii("cared"), - dictgen::InsensitiveStr::Ascii("cares"), - dictgen::InsensitiveStr::Ascii("caring"), - dictgen::InsensitiveStr::Ascii("cining"), - dictgen::InsensitiveStr::Ascii("earship"), - dictgen::InsensitiveStr::Ascii("earships"), - dictgen::InsensitiveStr::Ascii("egatie"), - dictgen::InsensitiveStr::Ascii("egaties"), - dictgen::InsensitiveStr::Ascii("egative"), - dictgen::InsensitiveStr::Ascii("epted"), - dictgen::InsensitiveStr::Ascii("erious"), - dictgen::InsensitiveStr::Ascii("evopment"), - dictgen::InsensitiveStr::Ascii("fation"), - dictgen::InsensitiveStr::Ascii("fect"), - dictgen::InsensitiveStr::Ascii("fection"), - dictgen::InsensitiveStr::Ascii("ibarate"), - dictgen::InsensitiveStr::Ascii("ibaretely"), - dictgen::InsensitiveStr::Ascii("iberant"), - dictgen::InsensitiveStr::Ascii("iberante"), - dictgen::InsensitiveStr::Ascii("iberatley"), - dictgen::InsensitiveStr::Ascii("iberatly"), - dictgen::InsensitiveStr::Ascii("iberetly"), - dictgen::InsensitiveStr::Ascii("ibirate"), - dictgen::InsensitiveStr::Ascii("ibirately"), - dictgen::InsensitiveStr::Ascii("ibitating"), - dictgen::InsensitiveStr::Ascii("ightlful"), - dictgen::InsensitiveStr::Ascii("igthful"), - dictgen::InsensitiveStr::Ascii("iverate"), - dictgen::InsensitiveStr::Ascii("iverately"), - dictgen::InsensitiveStr::Ascii("ivere"), - dictgen::InsensitiveStr::Ascii("iverees"), - dictgen::InsensitiveStr::Ascii("iveres"), - dictgen::InsensitiveStr::Ascii("iverying"), - dictgen::InsensitiveStr::Ascii("iverys"), - dictgen::InsensitiveStr::Ascii("iviered"), - dictgen::InsensitiveStr::Ascii("iviring"), - dictgen::InsensitiveStr::Ascii("peted"), - dictgen::InsensitiveStr::Ascii("porable"), - dictgen::InsensitiveStr::Ascii("poyed"), - dictgen::InsensitiveStr::Ascii("poying"), - dictgen::InsensitiveStr::Ascii("poyment"), - dictgen::InsensitiveStr::Ascii("usionally"), - dictgen::InsensitiveStr::Ascii("usionnal"), - dictgen::InsensitiveStr::Ascii("utional"), - dictgen::InsensitiveStr::Ascii("yaing"), + 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: None, +}; + +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("oyed"), + dictgen::InsensitiveStr::Ascii("oying"), + dictgen::InsensitiveStr::Ascii("oyment"), ], values: &[ - &["dealership"], - &["dealerships"], - &["delegates"], - &["dilapidated"], - &["declaration"], - &["declare"], - &["declared"], - &["declares"], - &["declaring"], - &["declining"], - &["dealership"], - &["dealerships"], - &["delegate"], - &["delegate"], - &["delegate"], - &["depleted"], - &["delirious"], - &["development"], - &["deflation"], - &["deflect"], - &["deflection"], - &["deliberate"], - &["deliberately"], - &["deliberate"], - &["deliberate"], - &["deliberately"], - &["deliberately"], - &["deliberately"], - &["deliberate"], - &["deliberately"], - &["debilitating"], - &["delightful"], - &["delightful"], - &["deliberate"], - &["deliberately"], - &["deliveries"], - &["deliveries"], - &["delivers"], - &["delivering"], - &["delivers"], - &["delivered"], - &["delivering"], &["depleted"], &["deplorable"], &["deployed"], &["deploying"], &["deployment"], - &["delusively"], - &["delusional"], - &["delusional"], - &["delaying"], ], - range: 4..=9, + range: 4..=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"], + &["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("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("ters"), + ], + values: &[ + &["delimited"], + &["delimiter"], + &["delimiters"], + &["delimited"], + &["delimiter"], + &["delimiters"], + &["delimitation"], + &["delimitations"], + &["delimitation"], + &["delimitations"], + &["delimited"], + &["delimiter"], + &["delimiters"], + &["delimiting"], + &["delimiting"], + &["delimitation"], + &["delimitations"], + &["delimits"], + &["delimitation"], + &["delimitations"], + &["delimited"], + &["delimiter"], + &["delimiters"], + &["delimiting"], + &["delimiter"], + &["delimiters"], + &["delimited"], + &["dilemma"], + &["delimited"], + &["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("vering"), + dictgen::InsensitiveStr::Ascii("very"), + dictgen::InsensitiveStr::Ascii("vred"), + dictgen::InsensitiveStr::Ascii("vries"), + dictgen::InsensitiveStr::Ascii("vry"), + ], + values: &[ + &["delivering"], + &["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("eratley"), + dictgen::InsensitiveStr::Ascii("eratly"), + dictgen::InsensitiveStr::Ascii("eretly"), + dictgen::InsensitiveStr::Ascii("erite"), + dictgen::InsensitiveStr::Ascii("eritely"), + 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"], + &["deliberate"], + &["deliberately"], + &["deliberate"], + &["deliberately"], + &["debilitating"], + &["deliberate"], + &["deliberately"], + ], + range: 4..=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("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("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"], + &["delimiter"], + &["delimiter"], + &["depleted"], + &["delirious"], + &["delete"], + &["deleted"], + &["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("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"], + &["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 { @@ -68041,11 +129199,20 @@ static WORD_DEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_DEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("laration"), dictgen::InsensitiveStr::Ascii("stop"), dictgen::InsensitiveStr::Ascii("stops"), + dictgen::InsensitiveStr::Ascii("top"), + dictgen::InsensitiveStr::Ascii("tops"), ], - values: &[&["desktop"], &["desktops"]], - range: 4..=5, + values: &[ + &["declaration"], + &["desktop"], + &["desktops"], + &["desktop"], + &["desktops"], + ], + range: 3..=8, }; static WORD_DEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68058,37 +129225,65 @@ pub static WORD_DEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("fnately"), dictgen::InsensitiveStr::Ascii("fnetly"), dictgen::InsensitiveStr::Ascii("fnitly"), + dictgen::InsensitiveStr::Ascii("miter"), + dictgen::InsensitiveStr::Ascii("ne"), + dictgen::InsensitiveStr::Ascii("ned"), dictgen::InsensitiveStr::Ascii("ners"), + 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("vce"), + dictgen::InsensitiveStr::Ascii("vces"), + dictgen::InsensitiveStr::Ascii("vices"), ], values: &[ &["definitely"], &["definitely"], &["definitely"], + &["delimiter"], + &["define"], + &["denied", "defined"], &["deniers"], + &["deinitialise"], + &["deinitialize"], &["deinitialization"], &["deinitialize"], &["deinitialized"], &["deinitializes"], &["deinitializing"], + &["deinstantiating"], + &["deinitialize"], + &["deinitialized"], + &["deinitializing"], + &["design"], &["designated"], &["designed"], &["designer"], &["designers"], + &["designing"], &["designs"], &["deviant"], + &["device"], + &["devices"], + &["devices"], ], - range: 4..=12, + range: 2..=12, }; static WORD_DEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68116,17 +129311,33 @@ pub static WORD_DEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("arde"), dictgen::InsensitiveStr::Ascii("arded"), dictgen::InsensitiveStr::Ascii("enarate"), + dictgen::InsensitiveStr::Ascii("enarated"), + dictgen::InsensitiveStr::Ascii("enarating"), + dictgen::InsensitiveStr::Ascii("enaration"), 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"), @@ -68134,23 +129345,47 @@ pub static WORD_DEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["degenerating"], + &["degeneration"], &["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"], @@ -68159,8 +129394,16 @@ pub static WORD_DEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["degrade"], &["degrade"], &["degradation"], + &["degradation"], + &["degree"], + &["degree"], + &["degrees"], + &["degrees"], + &["degrees", "digress"], + &["degrees", "digress"], + &["degradation"], ], - range: 4..=8, + range: 3..=9, }; static WORD_DEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68183,10 +129426,10 @@ static WORD_DEF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_DEFL_NODE), None, Some(&WORD_DEFN_NODE), + Some(&WORD_DEFO_NODE), None, - None, - None, - None, + Some(&WORD_DEFQ_NODE), + Some(&WORD_DEFR_NODE), None, None, Some(&WORD_DEFU_NODE), @@ -68205,10 +129448,45 @@ static WORD_DEFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), ], - values: &[&["default"], &["defaults"]], - range: 3..=4, + values: &[&["default"], &["defaultdict"], &["defaults"], &["default"]], + 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 { @@ -68218,11 +129496,22 @@ static WORD_DEFN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("itions"), ], - values: &[&["definitely"], &["definitely"]], - range: 5..=6, + values: &[ + &["defend", "defined"], + &["definitely"], + &["definitely"], + &["definition"], + &["definitions"], + &["definitions"], + ], + range: 2..=8, }; static WORD_DEFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68234,6 +129523,7 @@ pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -68243,13 +129533,14 @@ pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["deflection"], &["deflation"], + &["default"], &["deflection"], &["deflection"], &["deflection"], &["deflection"], &["deflection"], ], - range: 4..=7, + range: 3..=7, }; static WORD_DEFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68262,7 +129553,7 @@ static WORD_DEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_DEFIB_NODE), Some(&WORD_DEFIC_NODE), None, - None, + Some(&WORD_DEFIE_NODE), None, None, None, @@ -68295,28 +129586,32 @@ pub static WORD_DEFIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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: 4..=4, + range: 3..=4, }; static WORD_DEFIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_DEFIN_CHILDREN), - value: None, + value: Some(&["define"]), }; static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_DEFINA_NODE), None, None, - None, + Some(&WORD_DEFIND_NODE), Some(&WORD_DEFINE_NODE), None, None, @@ -68326,7 +129621,7 @@ static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, Some(&WORD_DEFINL_NODE), None, - None, + Some(&WORD_DEFINN_NODE), Some(&WORD_DEFINO_NODE), None, None, @@ -68354,34 +129649,44 @@ pub static WORD_DEFINU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d static WORD_DEFINT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_DEFINT_CHILDREN), - value: None, + 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("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"], &["definitely"], &["definition"], + &["definitions"], + &["definition"], + &["definitively"], &["definitely"], ], - range: 3..=4, + range: 1..=5, }; static WORD_DEFINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_DEFINS_CHILDREN), - value: None, + value: Some(&["defines", "define"]), }; pub static WORD_DEFINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -68401,6 +129706,20 @@ pub static WORD_DEFINO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -68433,13 +129752,19 @@ static WORD_DEFINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("ntion"), dictgen::InsensitiveStr::Ascii("t"), dictgen::InsensitiveStr::Ascii("taley"), dictgen::InsensitiveStr::Ascii("taly"), @@ -68448,13 +129773,17 @@ pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("titely"), dictgen::InsensitiveStr::Ascii("tivelly"), dictgen::InsensitiveStr::Ascii("tivley"), @@ -68470,19 +129799,27 @@ pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], + &["definition"], &["definite"], &["definitely"], &["definitely"], @@ -68491,13 +129828,17 @@ pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["definitively"], &["definitively"], &["definitely"], + &["definition"], &["definitive"], &["definitively"], &["definitive"], &["definitively"], + &["definition"], + &["definitions"], &["definitively"], &["definitions"], &["definitively"], + &["definition"], &["definitively"], &["definitively"], &["definitively"], @@ -68514,6 +129855,8 @@ pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["definitely"], &["definition"], &["definition"], + &["definition"], + &["definitions"], &["definitive"], &["definite"], &["definitely"], @@ -68528,7 +129871,10 @@ static WORD_DEFINE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"), @@ -68542,7 +129888,10 @@ pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("tyl"), ], values: &[ + &["defines"], &["definitely"], + &["defined"], + &["defined"], &["definite"], &["definitely"], &["definitely"], @@ -68558,6 +129907,17 @@ pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("ed")], + values: &[&["defined", "defunded"]], + range: 2..=2, +}; + static WORD_DEFINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_DEFINA_CHILDREN), value: None, @@ -68565,6 +129925,7 @@ static WORD_DEFINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -68594,6 +129955,7 @@ pub static WORD_DEFINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("yely"), ], values: &[ + &["defined"], &["definitely"], &["definitely"], &["definitely"], @@ -68636,6 +129998,21 @@ pub static WORD_DEFII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -68644,6 +130021,7 @@ static WORD_DEFIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -68661,6 +130039,7 @@ pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di ], values: &[ &["definitely"], + &["device"], &["deficient"], &["deficiencies"], &["deficiency"], @@ -68676,7 +130055,7 @@ pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["deficient"], &["deficits"], ], - range: 3..=7, + range: 1..=7, }; static WORD_DEFIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68705,7 +130084,7 @@ pub static WORD_DEFIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di values: &[ &["definitely"], &["defiantly"], - &["definitely"], + &["definitely", "defiantly"], &["definitely"], ], range: 4..=5, @@ -68719,11 +130098,37 @@ static WORD_DEFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DEFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("ensively"), + 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: &[&["defensively"], &["define"], &["defined"]], - range: 3..=8, + values: &[ + &["defensively"], + &["differed", "deferred"], + &["difference", "deference"], + &["different", "deferent"], + &["differential", "deferential"], + &["differently"], + &["differing"], + &["deferred"], + &["differs", "defers"], + &["define"], + &["defined"], + &["definition"], + &["definitively"], + &["different"], + ], + range: 3..=9, }; static WORD_DEFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68733,11 +130138,16 @@ static WORD_DEFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"), @@ -68753,6 +130163,10 @@ pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -68761,14 +130175,25 @@ pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("nsie"), dictgen::InsensitiveStr::Ascii("nsivley"), dictgen::InsensitiveStr::Ascii("nsivly"), + dictgen::InsensitiveStr::Ascii("ral"), + dictgen::InsensitiveStr::Ascii("rals"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("rentiating"), + dictgen::InsensitiveStr::Ascii("ring"), + dictgen::InsensitiveStr::Ascii("rreal"), dictgen::InsensitiveStr::Ascii("tead"), ], values: &[ + &["deficit"], &["defects"], &["defects"], + &["define"], + &["defines"], &["definitely"], &["deflect"], &["deflection"], + &["definite"], + &["definitely"], &["defends"], &["defender"], &["defendant"], @@ -68784,6 +130209,10 @@ pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["defenseless"], &["defenseman"], &["defensively"], + &["definitely"], + &["definition"], + &["definitions"], + &["definitely"], &["defends"], &["defenseman"], &["defenseless"], @@ -68792,9 +130221,15 @@ pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["defensive"], &["defensively"], &["defensively"], + &["deferral"], + &["deferrals"], + &["deferred"], + &["differentiating"], + &["deferring"], + &["deferral"], &["defeated"], ], - range: 3..=7, + range: 3..=10, }; static WORD_DEFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68805,56 +130240,223 @@ static WORD_DEFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"), ], 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"], + &["defaults"], + &["default", "defaults"], + &["default"], + &["default"], + &["defaulted"], + &["defaulting"], + &["defaults"], + &["default"], + &["defaultly"], &["defaults"], ], - range: 3..=6, + 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"), + ], + values: &[ + &["decorator"], + &["deep"], + &["delete"], + &["dependencies"], + &["dependency"], + ], + range: 2..=8, }; static WORD_DED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_DED_CHILDREN), - value: None, + value: Some(&["dead"]), }; pub static WORD_DED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ault"), + dictgen::InsensitiveStr::Ascii("ected"), + dictgen::InsensitiveStr::Ascii("ection"), dictgen::InsensitiveStr::Ascii("icacion"), dictgen::InsensitiveStr::Ascii("icato"), + dictgen::InsensitiveStr::Ascii("idated"), 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"], + &["detected"], + &["detection"], &["dedication"], &["dedication"], + &["dedicated"], &["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: 5..=8, + range: 2..=11, }; static WORD_DEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68865,7 +130467,7 @@ static WORD_DEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_DECA_NODE), None, - None, + Some(&WORD_DECC_NODE), None, Some(&WORD_DECE_NODE), None, @@ -68883,23 +130485,67 @@ static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_DECR_NODE), Some(&WORD_DECS_NODE), Some(&WORD_DECT_NODE), + Some(&WORD_DECU_NODE), None, None, 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")], - values: &[&["detect"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("ect"), + dictgen::InsensitiveStr::Ascii("ecte"), + dictgen::InsensitiveStr::Ascii("ected"), + dictgen::InsensitiveStr::Ascii("ecting"), + dictgen::InsensitiveStr::Ascii("ection"), + dictgen::InsensitiveStr::Ascii("ector"), + dictgen::InsensitiveStr::Ascii("ivate"), + ], + values: &[ + &["detect"], + &["detect", "detected", "detects"], + &["detected"], + &["detecting"], + &["detection"], + &["detector"], + &["deactivate"], + ], + range: 3..=6, }; static WORD_DECS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68914,6 +130560,12 @@ pub static WORD_DECS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("endants"), dictgen::InsensitiveStr::Ascii("ended"), dictgen::InsensitiveStr::Ascii("ending"), + 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"], @@ -68921,6 +130573,12 @@ pub static WORD_DECS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["descendants"], &["descended"], &["descending"], + &["descriptors"], + &["described"], + &["descriptor"], + &["descriptors"], + &["description"], + &["descriptions"], ], range: 3..=8, }; @@ -68932,22 +130590,66 @@ static WORD_DECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("emenet"), + dictgen::InsensitiveStr::Ascii("emenetd"), + dictgen::InsensitiveStr::Ascii("emeneted"), + dictgen::InsensitiveStr::Ascii("ese"), + dictgen::InsensitiveStr::Ascii("esing"), dictgen::InsensitiveStr::Ascii("ess"), 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("menet"), + dictgen::InsensitiveStr::Ascii("menetd"), + dictgen::InsensitiveStr::Ascii("meneted"), + dictgen::InsensitiveStr::Ascii("oation"), dictgen::InsensitiveStr::Ascii("oative"), + dictgen::InsensitiveStr::Ascii("pt"), + dictgen::InsensitiveStr::Ascii("pted"), + dictgen::InsensitiveStr::Ascii("ption"), + dictgen::InsensitiveStr::Ascii("ytion"), ], values: &[ + &["decreasing", "deceasing"], + &["decreasing", "deceasing"], + &["decoration"], + &["decrease"], + &["decrease"], + &["decrement"], + &["decremented"], + &["decremented"], + &["decrease"], + &["decreasing", "deceasing"], &["decrees"], &["describe"], &["described"], &["describes"], &["describing"], + &["description"], + &["descriptions"], + &["descriptor"], + &["descriptors"], + &["decrement"], + &["decremented"], + &["decremented"], + &["decoration"], &["decorative"], + &["decrypt"], + &["decrypted"], + &["decryption"], + &["decryption"], ], - range: 3..=6, + range: 2..=8, }; static WORD_DECP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -68965,46 +130667,285 @@ pub static WORD_DECP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_DECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DECO_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DECO_CHILDREN), value: None, }; -pub static WORD_DECO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("artions"), - dictgen::InsensitiveStr::Ascii("missioned"), - dictgen::InsensitiveStr::Ascii("mposeion"), - dictgen::InsensitiveStr::Ascii("mposit"), - dictgen::InsensitiveStr::Ascii("mposited"), - dictgen::InsensitiveStr::Ascii("mpositing"), - dictgen::InsensitiveStr::Ascii("mposits"), - dictgen::InsensitiveStr::Ascii("racion"), - dictgen::InsensitiveStr::Ascii("ratie"), - dictgen::InsensitiveStr::Ascii("ratieve"), - dictgen::InsensitiveStr::Ascii("ratin"), - dictgen::InsensitiveStr::Ascii("rativo"), - dictgen::InsensitiveStr::Ascii("rativos"), - dictgen::InsensitiveStr::Ascii("ritive"), - dictgen::InsensitiveStr::Ascii("tations"), + 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"), ], values: &[ &["decoration"], + &["decorated"], + &["decorative"], + &["decorative"], + &["decorations"], + &["decoration"], + &["decorations"], + &["decoration"], + &["decode"], + &["decoded"], + &["decoder"], + &["decoders"], + &["decodes"], + &["decoding"], + &["decodings"], + &["decorative"], + &["decorrelation"], + ], + 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("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("pse"), + ], + values: &[ &["decommissioned"], + &["decommissioning"], + &["decommission"], + &["decommissioned"], + &["decompress"], + &["decomposition"], + &["decomposition"], &["decomposition"], &["decompose"], &["decomposed"], &["decomposing"], &["decomposes"], - &["decoration"], - &["decorative"], - &["decorative"], - &["decorations"], - &["decoration"], - &["decorations"], - &["decorative"], - &["decorations"], + &["decomposition"], + &["decomposition"], + &["decompress"], + &["decompressed"], + &["decompressor"], + &["decompresses"], + &["decompressing"], + &["decompression"], + &["decompressor"], + &["decompressed"], + &["decompressor"], + &["decompose"], ], - range: 5..=9, + 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 { @@ -69025,38 +130966,108 @@ static WORD_DECL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_DECL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ar"), dictgen::InsensitiveStr::Ascii("aracion"), 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("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"], &["declares"], &["declares"], &["declares"], + &["declared"], + &["declarations"], + &["declaration"], + &["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"], - &["declares"], + &["declarations"], + &["declaration"], + &["declarations"], + &["declared"], + &["declaration"], + &["declarations"], + &["declaratory"], &["declares"], &["declaration"], + &["declarations"], &["declining"], &["declining"], &["declaration"], + &["declaration"], ], - range: 3..=8, + range: 2..=9, }; static WORD_DECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69066,10 +131077,30 @@ static WORD_DECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("pted"), dictgen::InsensitiveStr::Ascii("pting"), dictgen::InsensitiveStr::Ascii("ption"), @@ -69077,12 +131108,33 @@ pub static WORD_DECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["depicted"], &["depicting"], &["depiction"], @@ -69090,8 +131142,9 @@ pub static WORD_DECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["decisions"], &["decisive"], &["decision"], + &["decision"], ], - range: 3..=6, + range: 1..=6, }; static WORD_DECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69103,10 +131156,16 @@ pub static WORD_DECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ 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"), @@ -69116,17 +131175,34 @@ pub static WORD_DECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["december"], &["december"], + &["december"], + &["descend"], &["descendant"], &["descendants"], - &["descendent"], - &["descendents"], + &["descendent", "descendent", "descended"], + &["descendent", "descendent"], + &["descendant"], + &["descendants"], + &["descendents", "descendents"], + &["descending"], &["desensitized"], &["decentralized"], &["decentralized"], &["receptionist"], &["deceptive"], ], - range: 4..=9, + 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")], + values: &[&["decelerate"]], + range: 7..=7, }; static WORD_DECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69136,13 +131212,38 @@ static WORD_DECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["declare"], &["declared"], &["declares"], &["declaring"]], - range: 3..=5, + 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 { @@ -69152,43 +131253,343 @@ static WORD_DEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("gu"), + dictgen::InsensitiveStr::Ascii("gug"), + dictgen::InsensitiveStr::Ascii("guging"), + dictgen::InsensitiveStr::Ascii("iab"), + dictgen::InsensitiveStr::Ascii("loking"), + dictgen::InsensitiveStr::Ascii("th"), + dictgen::InsensitiveStr::Ascii("ths"), 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("ugginf"), + dictgen::InsensitiveStr::Ascii("uggs"), + dictgen::InsensitiveStr::Ascii("uging"), ], - values: &[&["debatable"], &["debuffs"], &["debuffs"]], - range: 5..=7, + values: &[ + &["debian"], + &["debatable"], + &["debugger"], + &["debug"], + &["debug"], + &["debugging"], + &["debian"], + &["deblocking"], + &["depth"], + &["depths"], + &["debuffs"], + &["debuffs"], + &["debugfs"], + &["debuggee"], + &["debugger"], + &["debug"], + &["debugging"], + &["debugs"], + &["debugging"], + ], + range: 2..=7, }; static WORD_DEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DEA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_DEA_CHILDREN), value: None, }; -pub static WORD_DEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + 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("dlfit"), - dictgen::InsensitiveStr::Ascii("dlfits"), - dictgen::InsensitiveStr::Ascii("dlifs"), - dictgen::InsensitiveStr::Ascii("dlifters"), - dictgen::InsensitiveStr::Ascii("dlit"), - dictgen::InsensitiveStr::Ascii("dpol"), - dictgen::InsensitiveStr::Ascii("dpoool"), - dictgen::InsensitiveStr::Ascii("feted"), - dictgen::InsensitiveStr::Ascii("fult"), - dictgen::InsensitiveStr::Ascii("fults"), - dictgen::InsensitiveStr::Ascii("htly"), - dictgen::InsensitiveStr::Ascii("lerhsip"), - dictgen::InsensitiveStr::Ascii("lershits"), - dictgen::InsensitiveStr::Ascii("lershp"), - dictgen::InsensitiveStr::Ascii("lying"), - dictgen::InsensitiveStr::Ascii("menor"), - dictgen::InsensitiveStr::Ascii("thamtch"), - dictgen::InsensitiveStr::Ascii("thcat"), - dictgen::InsensitiveStr::Ascii("thmacth"), - dictgen::InsensitiveStr::Ascii("thmath"), - dictgen::InsensitiveStr::Ascii("tils"), - dictgen::InsensitiveStr::Ascii("tlhy"), + dictgen::InsensitiveStr::Ascii("lts"), + dictgen::InsensitiveStr::Ascii("thenication"), + ], + values: &[&["defaults"], &["deauthentication"]], + range: 3..=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("ils"), + dictgen::InsensitiveStr::Ascii("ivate"), + dictgen::InsensitiveStr::Ascii("ivated"), + dictgen::InsensitiveStr::Ascii("ivates"), + dictgen::InsensitiveStr::Ascii("ivation"), + dictgen::InsensitiveStr::Ascii("lhy"), + ], + values: &[ + &["detach"], + &["detached"], + &["detaches"], + &["detaching"], + &["deathmatch"], + &["deathmatch"], + &["deathmatch"], + &["deathmatch"], + &["details"], + &["deactivate"], + &["deactivated"], + &["deactivates"], + &["deactivation"], + &["deathly"], + ], + range: 2..=7, +}; + +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_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"], @@ -69198,23 +131599,35 @@ pub static WORD_DEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["deadlift"], &["deadpool"], &["deadpool"], - &["defeated"], - &["default"], - &["defaults"], - &["deathly"], - &["dealerships"], - &["dealerships"], - &["dealerships"], - &["delaying"], - &["demeanor"], - &["deathmatch"], - &["deathmatch"], - &["deathmatch"], - &["deathmatch"], - &["details"], - &["deathly"], ], - range: 4..=8, + 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("tivatiion"), + dictgen::InsensitiveStr::Ascii("tive"), + dictgen::InsensitiveStr::Ascii("tiveate"), + dictgen::InsensitiveStr::Ascii("tived"), + dictgen::InsensitiveStr::Ascii("tiving"), + ], + values: &[ + &["deactivation"], + &["deactivated"], + &["deactivation"], + &["deactivate"], + &["deactivate"], + &["deactivated"], + &["deactivating"], + ], + range: 4..=9, }; static WORD_DD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69231,79 +131644,495 @@ pub static WORD_DD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg range: 5..=5, }; -static WORD_DA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_DA_CHILDREN), +static WORD_DC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_DC_CHILDREN), value: None, }; -pub static WORD_DA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_DC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("bilitating"), - dictgen::InsensitiveStr::Ascii("cquiri"), - dictgen::InsensitiveStr::Ascii("ed"), - dictgen::InsensitiveStr::Ascii("el"), - dictgen::InsensitiveStr::Ascii("gners"), - dictgen::InsensitiveStr::Ascii("hsboard"), - dictgen::InsensitiveStr::Ascii("imond"), - dictgen::InsensitiveStr::Ascii("imonds"), - dictgen::InsensitiveStr::Ascii("lmation"), - dictgen::InsensitiveStr::Ascii("menor"), - dictgen::InsensitiveStr::Ascii("mmage"), - dictgen::InsensitiveStr::Ascii("ngeros"), - dictgen::InsensitiveStr::Ascii("ngeroulsy"), - dictgen::InsensitiveStr::Ascii("ngerouly"), - dictgen::InsensitiveStr::Ascii("ngerousely"), - dictgen::InsensitiveStr::Ascii("ngeroys"), - dictgen::InsensitiveStr::Ascii("ngerus"), - dictgen::InsensitiveStr::Ascii("rcula"), - dictgen::InsensitiveStr::Ascii("rdenelles"), - dictgen::InsensitiveStr::Ascii("rgons"), - dictgen::InsensitiveStr::Ascii("rkenss"), - dictgen::InsensitiveStr::Ascii("rkets"), - dictgen::InsensitiveStr::Ascii("rnkess"), - dictgen::InsensitiveStr::Ascii("shbaord"), - dictgen::InsensitiveStr::Ascii("shboad"), - dictgen::InsensitiveStr::Ascii("tbase"), - dictgen::InsensitiveStr::Ascii("ugther"), - dictgen::InsensitiveStr::Ascii("ugthers"), - dictgen::InsensitiveStr::Ascii("ulity"), - dictgen::InsensitiveStr::Ascii("vantage"), - dictgen::InsensitiveStr::Ascii("wrves"), + 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: &[ - &["debilitating"], - &["daiquiri"], - &["dead"], - &["deal"], - &["dangers"], + &["dhcp"], + &["dock"], + &["docked"], + &["docker"], + &["dockerd", "docked", "docker"], + &["docking"], + &["docks"], + &["document"], + &["documented"], + &["documenting"], + &["documents"], + ], + range: 2..=8, +}; + +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, + None, + None, +]; + +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("abas"), + 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("base"), + dictgen::InsensitiveStr::Ascii("bases"), + dictgen::InsensitiveStr::Ascii("ea"), + dictgen::InsensitiveStr::Ascii("ecreatedd"), + dictgen::InsensitiveStr::Ascii("ection"), + dictgen::InsensitiveStr::Ascii("ee"), + dictgen::InsensitiveStr::Ascii("set"), + dictgen::InsensitiveStr::Ascii("sets"), + dictgen::InsensitiveStr::Ascii("y"), + ], + values: &[ + &["database"], + &["databases"], + &["database"], + &["database"], + &["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"], + &["database"], + &["databases"], + &["date", "data"], + &["datecreated"], + &["detection"], + &["date"], + &["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("dot"), + dictgen::InsensitiveStr::Ascii("hbaord"), + dictgen::InsensitiveStr::Ascii("hboad"), + dictgen::InsensitiveStr::Ascii("hbord"), + dictgen::InsensitiveStr::Ascii("hbords"), + dictgen::InsensitiveStr::Ascii("hs"), + dictgen::InsensitiveStr::Ascii("y"), + ], + values: &[ + &["dashdot"], &["dashboard"], - &["diamond"], - &["diamonds"], - &["dalmatian"], - &["demeanor"], - &["damage"], - &["dangers"], - &["dangerously"], - &["dangerously"], - &["dangerously"], - &["dangerously"], - &["dangers"], + &["dashboard"], + &["dashboard"], + &["dashboards"], + &["dashes"], + &["daisy"], + ], + range: 1..=6, +}; + +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("nkess"), + ], + values: &[ &["dracula"], &["dardanelles"], &["dragons"], &["darkness"], &["darkest"], &["darkness"], - &["dashboard"], - &["dashboard"], - &["database"], - &["daughter"], - &["daughters"], - &["duality"], - &["advantage"], - &["dwarves"], ], - range: 2..=10, + range: 4..=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("geros"), + dictgen::InsensitiveStr::Ascii("geroulsy"), + dictgen::InsensitiveStr::Ascii("gerouly"), + dictgen::InsensitiveStr::Ascii("gerousely"), + dictgen::InsensitiveStr::Ascii("geroys"), + dictgen::InsensitiveStr::Ascii("gerus"), + ], + values: &[ + &["dancing"], + &["candidates"], + &["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("enor"), + dictgen::InsensitiveStr::Ascii("eon"), + dictgen::InsensitiveStr::Ascii("ge"), + dictgen::InsensitiveStr::Ascii("mage"), + dictgen::InsensitiveStr::Ascii("mages"), + ], + values: &[ + &["demeanor"], + &["daemon", "demon", "damien"], + &["damage"], + &["damage"], + &["damages"], + ], + range: 2..=5, +}; + +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("mation"), + dictgen::InsensitiveStr::Ascii("ta"), + ], + values: &[&["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("laration"), + dictgen::InsensitiveStr::Ascii("quiri"), + ], + values: &[&["declaration"], &["daiquiri"]], + range: 5..=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"), + ], + values: &[&["database"], &["debilitating"]], + range: 3..=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 { @@ -69314,18 +132143,18 @@ static WORD_C_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_CA_NODE), None, - None, - None, + Some(&WORD_CC_NODE), + Some(&WORD_CD_NODE), Some(&WORD_CE_NODE), None, - None, + Some(&WORD_CG_NODE), Some(&WORD_CH_NODE), Some(&WORD_CI_NODE), - None, - None, + Some(&WORD_CJ_NODE), + Some(&WORD_CK_NODE), Some(&WORD_CL_NODE), Some(&WORD_CM_NODE), - None, + Some(&WORD_CN_NODE), Some(&WORD_CO_NODE), Some(&WORD_CP_NODE), None, @@ -69333,7 +132162,7 @@ static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_CT_NODE), Some(&WORD_CU_NODE), - None, + Some(&WORD_CV_NODE), None, Some(&WORD_CX_NODE), Some(&WORD_CY_NODE), @@ -69348,47 +132177,109 @@ static WORD_CY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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("lindre"), dictgen::InsensitiveStr::Ascii("lindres"), + dictgen::InsensitiveStr::Ascii("lnder"), + dictgen::InsensitiveStr::Ascii("lnders"), + dictgen::InsensitiveStr::Ascii("lynders"), + dictgen::InsensitiveStr::Ascii("mk"), 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"], + &["cyclic"], + &["cyclical"], &["cyclist"], &["cyclists"], &["cyclone"], &["cyclops"], + &["cycle"], + &["cyclic"], + &["cylinder"], + &["cylinders"], &["cylinder"], &["cylinder"], &["cylinders"], + &["cylinder"], + &["cylinders"], + &["cylinders"], + &["cmyk"], &["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: 5..=7, + range: 2..=13, }; static WORD_CX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69402,6 +132293,17 @@ pub static WORD_CX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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, @@ -69416,7 +132318,7 @@ static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, + Some(&WORD_CUI_NODE), None, None, Some(&WORD_CUL_NODE), @@ -69428,8 +132330,8 @@ static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_CUR_NODE), Some(&WORD_CUS_NODE), Some(&WORD_CUT_NODE), - None, - None, + Some(&WORD_CUU_NODE), + Some(&WORD_CUV_NODE), None, None, None, @@ -69450,6 +132352,36 @@ pub static WORD_CUZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 9..=10, }; +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")], + values: &[&["currently"]], + range: 6..=6, +}; + static WORD_CUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CUT_CHILDREN), value: None, @@ -69457,6 +132389,8 @@ static WORD_CUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -69465,8 +132399,11 @@ pub static WORD_CUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("scenses"), dictgen::InsensitiveStr::Ascii("sence"), dictgen::InsensitiveStr::Ascii("sences"), + dictgen::InsensitiveStr::Ascii("ted"), ], values: &[ + &["cut", "cute", "cuter"], + &["custom"], &["cutscene"], &["cutscenes"], &["cutscene"], @@ -69475,8 +132412,9 @@ pub static WORD_CUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["cutscene"], &["cutscene"], &["cutscenes"], + &["cut"], ], - range: 5..=7, + range: 2..=7, }; static WORD_CUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69491,12 +132429,52 @@ pub static WORD_CUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tcenes"), dictgen::InsensitiveStr::Ascii("timizable"), dictgen::InsensitiveStr::Ascii("timized"), + dictgen::InsensitiveStr::Ascii("toisable"), + dictgen::InsensitiveStr::Ascii("toisation"), + dictgen::InsensitiveStr::Ascii("toise"), + dictgen::InsensitiveStr::Ascii("toised"), + dictgen::InsensitiveStr::Ascii("toiser"), + dictgen::InsensitiveStr::Ascii("toisers"), + dictgen::InsensitiveStr::Ascii("toising"), + dictgen::InsensitiveStr::Ascii("toizable"), + dictgen::InsensitiveStr::Ascii("toization"), + dictgen::InsensitiveStr::Ascii("toize"), + dictgen::InsensitiveStr::Ascii("toized"), + dictgen::InsensitiveStr::Ascii("toizer"), + dictgen::InsensitiveStr::Ascii("toizers"), + dictgen::InsensitiveStr::Ascii("toizing"), + dictgen::InsensitiveStr::Ascii("tomable"), + dictgen::InsensitiveStr::Ascii("tome"), + dictgen::InsensitiveStr::Ascii("tomicable"), + dictgen::InsensitiveStr::Ascii("tomie"), + dictgen::InsensitiveStr::Ascii("tomied"), dictgen::InsensitiveStr::Ascii("tomizabe"), dictgen::InsensitiveStr::Ascii("tomizaton"), dictgen::InsensitiveStr::Ascii("tomizble"), dictgen::InsensitiveStr::Ascii("tomizeble"), dictgen::InsensitiveStr::Ascii("tomizible"), + dictgen::InsensitiveStr::Ascii("tomsied"), dictgen::InsensitiveStr::Ascii("tomzied"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tonary"), + dictgen::InsensitiveStr::Ascii("toner"), + dictgen::InsensitiveStr::Ascii("toners"), + dictgen::InsensitiveStr::Ascii("tonisable"), + dictgen::InsensitiveStr::Ascii("tonisation"), + dictgen::InsensitiveStr::Ascii("tonise"), + dictgen::InsensitiveStr::Ascii("tonised"), + dictgen::InsensitiveStr::Ascii("toniser"), + dictgen::InsensitiveStr::Ascii("tonisers"), + dictgen::InsensitiveStr::Ascii("tonising"), + dictgen::InsensitiveStr::Ascii("tonizable"), + dictgen::InsensitiveStr::Ascii("tonization"), + dictgen::InsensitiveStr::Ascii("tonize"), + dictgen::InsensitiveStr::Ascii("tonized"), + dictgen::InsensitiveStr::Ascii("tonizer"), + dictgen::InsensitiveStr::Ascii("tonizers"), + dictgen::InsensitiveStr::Ascii("tonizing"), + dictgen::InsensitiveStr::Ascii("tons"), + dictgen::InsensitiveStr::Ascii("tumised"), dictgen::InsensitiveStr::Ascii("tumizable"), dictgen::InsensitiveStr::Ascii("tumization"), dictgen::InsensitiveStr::Ascii("tumized"), @@ -69507,114 +132485,384 @@ pub static WORD_CUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["cutscenes"], &["customizable"], &["customized"], + &["customisable"], + &["customisation"], + &["customise"], + &["customised"], + &["customiser"], + &["customisers"], + &["customising"], + &["customizable"], + &["customization"], + &["customize"], + &["customized"], + &["customizer"], + &["customizers"], + &["customizing"], + &["customizable"], + &["custom", "customs", "costume", "customer"], + &["customisable", "customizable"], + &["customize"], + &["customized"], &["customizable"], &["customization"], &["customizable"], &["customizable"], &["customizable"], + &["customised"], &["customized"], + &["custom"], + &["customary"], + &["customer"], + &["customers"], + &["customisable"], + &["customisation"], + &["customise"], + &["customised"], + &["customiser"], + &["customisers"], + &["customising"], + &["customizable"], + &["customization"], + &["customize"], + &["customized"], + &["customizer"], + &["customizers"], + &["customizing"], + &["customs"], + &["customised"], &["customizable"], &["customization"], &["customized"], ], - range: 5..=10, + range: 3..=10, }; static WORD_CUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CUR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CUR_CHILDREN), value: None, }; -pub static WORD_CUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("elinear")], + values: &[&["curvilinear"]], + range: 7..=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("ian")], + values: &[&["curtain"]], + range: 3..=3, +}; + +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("atin"), - dictgen::InsensitiveStr::Ascii("cial"), - dictgen::InsensitiveStr::Ascii("cible"), - dictgen::InsensitiveStr::Ascii("cuit"), - dictgen::InsensitiveStr::Ascii("cumcision"), - dictgen::InsensitiveStr::Ascii("cumference"), - dictgen::InsensitiveStr::Ascii("cumstance"), - dictgen::InsensitiveStr::Ascii("cumstances"), - dictgen::InsensitiveStr::Ascii("cumstantial"), - dictgen::InsensitiveStr::Ascii("elty"), - dictgen::InsensitiveStr::Ascii("iostiy"), - dictgen::InsensitiveStr::Ascii("iser"), - dictgen::InsensitiveStr::Ascii("isers"), - dictgen::InsensitiveStr::Ascii("ising"), - dictgen::InsensitiveStr::Ascii("isoity"), - dictgen::InsensitiveStr::Ascii("isve"), - dictgen::InsensitiveStr::Ascii("rancies"), - dictgen::InsensitiveStr::Ascii("rate"), - dictgen::InsensitiveStr::Ascii("recny"), - dictgen::InsensitiveStr::Ascii("rence"), - dictgen::InsensitiveStr::Ascii("renctly"), - dictgen::InsensitiveStr::Ascii("renices"), - dictgen::InsensitiveStr::Ascii("renlty"), - dictgen::InsensitiveStr::Ascii("renly"), - dictgen::InsensitiveStr::Ascii("rens"), - dictgen::InsensitiveStr::Ascii("rentfps"), - dictgen::InsensitiveStr::Ascii("rentlys"), - dictgen::InsensitiveStr::Ascii("rentpos"), - dictgen::InsensitiveStr::Ascii("rentusa"), - dictgen::InsensitiveStr::Ascii("renty"), - dictgen::InsensitiveStr::Ascii("reny"), - dictgen::InsensitiveStr::Ascii("rest"), - dictgen::InsensitiveStr::Ascii("riculem"), - dictgen::InsensitiveStr::Ascii("riculim"), - dictgen::InsensitiveStr::Ascii("ricullum"), - dictgen::InsensitiveStr::Ascii("riculm"), - dictgen::InsensitiveStr::Ascii("riences"), - dictgen::InsensitiveStr::Ascii("roption"), - dictgen::InsensitiveStr::Ascii("sade"), - dictgen::InsensitiveStr::Ascii("sader"), - dictgen::InsensitiveStr::Ascii("saders"), - dictgen::InsensitiveStr::Ascii("tian"), + 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: &[ - &["curtain"], - &["crucial"], - &["crucible"], - &["circuit"], - &["circumcision"], - &["circumference"], - &["circumstance"], - &["circumstances"], - &["circumstantial"], - &["cruelty"], + &["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("ecny"), + dictgen::InsensitiveStr::Ascii("ect"), + dictgen::InsensitiveStr::Ascii("ected"), + dictgen::InsensitiveStr::Ascii("ecting"), + dictgen::InsensitiveStr::Ascii("ectly"), + dictgen::InsensitiveStr::Ascii("ects"), + dictgen::InsensitiveStr::Ascii("eent"), + dictgen::InsensitiveStr::Ascii("eents"), + dictgen::InsensitiveStr::Ascii("emt"), + 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("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("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"], + &["currency"], + &["correct", "current"], + &["corrected"], + &["correcting"], + &["correctly", "currently"], + &["corrects", "currents"], + &["current"], + &["currents"], + &["current"], + &["currents"], + &["current"], + &["currencies"], + &["currency"], + &["currencies"], + &["currently"], + &["currently"], + &["current"], + &["currently"], + &["currents"], + &["currents"], + &["currents"], + &["currently"], + &["currently"], + &["currents"], + &["currents"], + &["currently"], + &["currents"], + &["currently"], + &["currency"], + &["corresponding"], + &["currents"], + &["currently"], + &["currently"], + &["curriculum"], + &["curriculum"], + &["curriculum"], + &["curriculum"], + &["currencies"], + &["curious"], + &["current"], + &["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("ilinear")], + values: &[&["curvilinear"]], + range: 7..=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("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"], + &["curiosities"], &["curiosity"], &["cruiser"], &["cruisers"], &["cruising"], &["curiosity"], &["cursive"], - &["currencies"], - &["curate"], - &["currency"], - &["currencies"], - &["currency"], - &["currencies"], - &["currently"], - &["currently"], - &["currents"], - &["currents"], - &["currents"], - &["currents"], - &["currents"], - &["currently"], - &["currency"], - &["currents"], - &["curriculum"], - &["curriculum"], - &["curriculum"], - &["curriculum"], - &["currencies"], - &["corruption"], - &["crusade"], - &["crusader"], - &["crusaders"], - &["curtain"], ], - range: 4..=11, + 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"), + ], + values: &[ + &["careful"], + &["carefully"], + &["carefully"], + &["cruelty"], + &["current"], + &["currentfilter"], + &["currently"], + &["current"], + &["currently"], + ], + range: 2..=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("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: &[ + &["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("tin")], + values: &[&["curtain"]], + range: 3..=3, }; static WORD_CUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69639,9 +132887,13 @@ static WORD_CUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_CUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("taminated")], - values: &[&["contaminated"]], - range: 9..=9, + keys: &[ + dictgen::InsensitiveStr::Ascii("curency"), + dictgen::InsensitiveStr::Ascii("taminated"), + dictgen::InsensitiveStr::Ascii("ter"), + ], + values: &[&["concurrency"], &["contaminated"], &["counter"]], + range: 3..=9, }; static WORD_CUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69653,18 +132905,28 @@ pub static WORD_CUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("bersone"), dictgen::InsensitiveStr::Ascii("bursome"), + dictgen::InsensitiveStr::Ascii("lative"), + dictgen::InsensitiveStr::Ascii("mand"), + dictgen::InsensitiveStr::Ascii("mulative"), + dictgen::InsensitiveStr::Ascii("municate"), dictgen::InsensitiveStr::Ascii("polsory"), dictgen::InsensitiveStr::Ascii("ulatative"), + dictgen::InsensitiveStr::Ascii("ulattive"), dictgen::InsensitiveStr::Ascii("ulitive"), ], values: &[ &["cumbersome"], &["cumbersome"], + &["cumulative"], + &["command"], + &["cumulative"], + &["communicate"], &["compulsory"], &["cumulative"], &["cumulative"], + &["cumulative"], ], - range: 7..=9, + range: 4..=9, }; static WORD_CUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69708,15 +132970,36 @@ pub static WORD_CUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("stionable")], - values: &[&["questionable"]], - range: 9..=9, + 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 { @@ -69757,16 +133040,24 @@ pub static WORD_CUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: 4..=7, + range: 2..=7, }; static WORD_CT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69781,6 +133072,10 @@ pub static WORD_CT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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: &[ @@ -69789,9 +133084,13 @@ pub static WORD_CT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["cthulhu"], &["cthulhu"], &["cthulhu"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certification"], &["cthulhu"], ], - range: 5..=6, + range: 5..=9, }; static WORD_CR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69817,7 +133116,7 @@ static WORD_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_CRO_NODE), Some(&WORD_CRP_NODE), None, - None, + Some(&WORD_CRR_NODE), Some(&WORD_CRS_NODE), Some(&WORD_CRT_NODE), Some(&WORD_CRU_NODE), @@ -69836,6 +133135,9 @@ static WORD_CRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("pitc"), + dictgen::InsensitiveStr::Ascii("pted"), + dictgen::InsensitiveStr::Ascii("ptocraphic"), + dictgen::InsensitiveStr::Ascii("ptograpic"), dictgen::InsensitiveStr::Ascii("stalens"), dictgen::InsensitiveStr::Ascii("stalisation"), dictgen::InsensitiveStr::Ascii("stalisk"), @@ -69845,12 +133147,17 @@ pub static WORD_CRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], + &["encrypted"], + &["cryptographic"], + &["cryptographic"], &["crystals"], &["crystallisation"], &["crystals"], @@ -69860,11 +133167,13 @@ pub static WORD_CRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["crystals"], &["crystals"], &["crystals"], + &["crypto"], &["cryptographic"], &["cryptic"], + &["crypto"], &["crystal"], ], - range: 4..=11, + range: 2..=11, }; static WORD_CRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69876,6 +133185,7 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -69883,6 +133193,8 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -69891,14 +133203,19 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), ], values: &[ &["crusader"], &["crucial"], + &["crucially"], &["crucible"], &["crucible"], &["crucifixion"], @@ -69906,6 +133223,8 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["crucial"], &["crucible"], &["cruelty"], + &["crunching"], + &["current"], &["crusade"], &["crusader"], &["crusaders"], @@ -69914,12 +133233,16 @@ pub static WORD_CRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["cruises"], &["cruising"], &["cursive"], + &["cursor"], &["crutches"], &["crutches"], &["crutches"], &["crutches"], + &["crucial"], + &["crucially"], + &["crucially"], ], - range: 4..=9, + range: 3..=9, }; static WORD_CRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -69942,9 +133265,38 @@ static WORD_CRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_CRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ytal")], - values: &[&["crystal"]], - range: 4..=4, + 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 { @@ -69966,45 +133318,65 @@ static WORD_CRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("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"), ], values: &[ &["croatia"], + &["crotch"], + &["crocodile"], &["crocodiles"], &["crocodile"], &["crocodile"], &["crocodile"], + &["chronological"], + &["chronologically"], &["corporation"], &["corporations"], + &["cropped"], &["corpses"], + &["cross"], &["corsair"], + &["crochet"], &["crossfire"], &["crossfire"], &["crossfire"], &["crosshair"], &["crosshair"], &["crossfire"], + &["crossing"], &["crosspost"], &["crowbar"], + &["crowdsignal"], + &["croquet"], &["crown"], ], - range: 2..=9, + range: 1..=11, }; static WORD_CRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70030,7 +133402,7 @@ static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, - None, + Some(&WORD_CRIR_NODE), None, Some(&WORD_CRIT_NODE), None, @@ -70042,79 +133414,116 @@ static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] ]; static WORD_CRIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CRIT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CRIT_CHILDREN), value: None, }; -pub static WORD_CRIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, +]; + +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("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("ereon"), - dictgen::InsensitiveStr::Ascii("erias"), - dictgen::InsensitiveStr::Ascii("icable"), - dictgen::InsensitiveStr::Ascii("icallity"), - dictgen::InsensitiveStr::Ascii("icaly"), - dictgen::InsensitiveStr::Ascii("icarlo"), - dictgen::InsensitiveStr::Ascii("icas"), - dictgen::InsensitiveStr::Ascii("ices"), - dictgen::InsensitiveStr::Ascii("icicing"), - dictgen::InsensitiveStr::Ascii("icie"), - dictgen::InsensitiveStr::Ascii("icies"), - dictgen::InsensitiveStr::Ascii("iciing"), - dictgen::InsensitiveStr::Ascii("icim"), - dictgen::InsensitiveStr::Ascii("icis"), - dictgen::InsensitiveStr::Ascii("icisied"), - dictgen::InsensitiveStr::Ascii("icisim"), - dictgen::InsensitiveStr::Ascii("icisims"), - dictgen::InsensitiveStr::Ascii("icisize"), - dictgen::InsensitiveStr::Ascii("icisme"), - dictgen::InsensitiveStr::Ascii("icisn"), - dictgen::InsensitiveStr::Ascii("icisng"), - dictgen::InsensitiveStr::Ascii("icists"), - dictgen::InsensitiveStr::Ascii("icisze"), - dictgen::InsensitiveStr::Ascii("iciszed"), - dictgen::InsensitiveStr::Ascii("iciszing"), - dictgen::InsensitiveStr::Ascii("icizms"), - dictgen::InsensitiveStr::Ascii("icizng"), - dictgen::InsensitiveStr::Ascii("icms"), - dictgen::InsensitiveStr::Ascii("icos"), - dictgen::InsensitiveStr::Ascii("icts"), - dictgen::InsensitiveStr::Ascii("icus"), - dictgen::InsensitiveStr::Ascii("iera"), - dictgen::InsensitiveStr::Ascii("isice"), - dictgen::InsensitiveStr::Ascii("isiced"), - dictgen::InsensitiveStr::Ascii("isicing"), - dictgen::InsensitiveStr::Ascii("isicm"), - dictgen::InsensitiveStr::Ascii("isicms"), - dictgen::InsensitiveStr::Ascii("isicsm"), - dictgen::InsensitiveStr::Ascii("ising"), - dictgen::InsensitiveStr::Ascii("isiscm"), - dictgen::InsensitiveStr::Ascii("isising"), - dictgen::InsensitiveStr::Ascii("isism"), - dictgen::InsensitiveStr::Ascii("isisms"), - dictgen::InsensitiveStr::Ascii("isize"), - dictgen::InsensitiveStr::Ascii("isizes"), - dictgen::InsensitiveStr::Ascii("isizms"), - dictgen::InsensitiveStr::Ascii("ized"), - dictgen::InsensitiveStr::Ascii("iziced"), - dictgen::InsensitiveStr::Ascii("izicing"), - dictgen::InsensitiveStr::Ascii("izing"), - dictgen::InsensitiveStr::Ascii("izised"), - dictgen::InsensitiveStr::Ascii("izising"), - dictgen::InsensitiveStr::Ascii("izisms"), - dictgen::InsensitiveStr::Ascii("izized"), - dictgen::InsensitiveStr::Ascii("izizing"), + dictgen::InsensitiveStr::Ascii("ical"), + 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: &[ - &["criteria"], - &["criterion"], - &["criteria"], + &["critical"], &["critical"], &["critically"], &["critically"], &["critical"], &["critics"], &["critics"], + &["critical"], + &["critically"], &["criticising"], &["criticise"], &["criticise"], @@ -70139,19 +133548,22 @@ pub static WORD_CRIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["critics"], &["critics"], &["criteria"], + &["critical"], &["criticise"], &["criticized"], &["criticizing"], &["criticism"], &["criticisms"], &["criticisms"], - &["criticising"], + &["criticising", "criticising"], &["criticisms"], &["criticising"], &["criticism"], &["criticisms"], - &["criticize"], - &["criticizes"], + &["criticize", "criticize"], + &["criticized", "criticized"], + &["criticizes", "criticizes"], + &["criticizing", "criticizing"], &["criticisms"], &["criticized"], &["criticized"], @@ -70163,7 +133575,52 @@ pub static WORD_CRIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["criticized"], &["criticizing"], ], - range: 3..=8, + 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("ial")], + values: &[&["critical"]], + range: 3..=3, +}; + +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")], + values: &[&["critical"]], + range: 4..=4, }; static WORD_CRIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70240,6 +133697,7 @@ static WORD_CRIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ital"), dictgen::InsensitiveStr::Ascii("itising"), dictgen::InsensitiveStr::Ascii("ketts"), dictgen::InsensitiveStr::Ascii("les"), @@ -70248,6 +133706,7 @@ pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("umference"), ], values: &[ + &["critical"], &["criticising"], &["crickets"], &["circles"], @@ -70270,64 +133729,236 @@ pub static WORD_CRH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_CRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CRE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CRE_CHILDREN), value: None, }; -pub static WORD_CRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("acionism"), - dictgen::InsensitiveStr::Ascii("aeted"), - dictgen::InsensitiveStr::Ascii("amic"), - dictgen::InsensitiveStr::Ascii("atein"), - dictgen::InsensitiveStr::Ascii("aten"), - dictgen::InsensitiveStr::Ascii("ater"), - dictgen::InsensitiveStr::Ascii("ateur"), - dictgen::InsensitiveStr::Ascii("atie"), - dictgen::InsensitiveStr::Ascii("atien"), - dictgen::InsensitiveStr::Ascii("ationis"), - dictgen::InsensitiveStr::Ascii("ationisim"), - dictgen::InsensitiveStr::Ascii("ationistas"), - dictgen::InsensitiveStr::Ascii("ationkit"), - dictgen::InsensitiveStr::Ascii("ationnism"), - dictgen::InsensitiveStr::Ascii("ationnist"), - dictgen::InsensitiveStr::Ascii("ationsim"), - dictgen::InsensitiveStr::Ascii("ationsism"), - dictgen::InsensitiveStr::Ascii("ationsist"), - dictgen::InsensitiveStr::Ascii("ationsit"), - dictgen::InsensitiveStr::Ascii("ationsits"), - dictgen::InsensitiveStr::Ascii("ationsm"), - dictgen::InsensitiveStr::Ascii("ationst"), - dictgen::InsensitiveStr::Ascii("ationsts"), - dictgen::InsensitiveStr::Ascii("ativelly"), - dictgen::InsensitiveStr::Ascii("ativey"), - dictgen::InsensitiveStr::Ascii("ativily"), - dictgen::InsensitiveStr::Ascii("ativley"), - dictgen::InsensitiveStr::Ascii("atue"), - dictgen::InsensitiveStr::Ascii("dencials"), - dictgen::InsensitiveStr::Ascii("dentails"), - dictgen::InsensitiveStr::Ascii("dentaisl"), - dictgen::InsensitiveStr::Ascii("dibillity"), - dictgen::InsensitiveStr::Ascii("dibilty"), - dictgen::InsensitiveStr::Ascii("dientals"), - dictgen::InsensitiveStr::Ascii("dintials"), - dictgen::InsensitiveStr::Ascii("edence"), - dictgen::InsensitiveStr::Ascii("eperest"), - dictgen::InsensitiveStr::Ascii("epes"), - dictgen::InsensitiveStr::Ascii("epgin"), - dictgen::InsensitiveStr::Ascii("epig"), - dictgen::InsensitiveStr::Ascii("ulty"), + dictgen::InsensitiveStr::Ascii("ae"), + dictgen::InsensitiveStr::Ascii("aed"), + dictgen::InsensitiveStr::Ascii("aes"), + dictgen::InsensitiveStr::Ascii("aing"), + dictgen::InsensitiveStr::Ascii("ates"), + dictgen::InsensitiveStr::Ascii("ed"), ], values: &[ + &["create"], + &["created"], + &["creates"], + &["creating"], + &["creates"], + &["created"], + ], + range: 2..=4, +}; + +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("its"), + ], + values: &[&["crescent"], &["credits"]], + range: 3..=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("entails"), + dictgen::InsensitiveStr::Ascii("entaisl"), + dictgen::InsensitiveStr::Ascii("etial"), + dictgen::InsensitiveStr::Ascii("etials"), + dictgen::InsensitiveStr::Ascii("ibillity"), + dictgen::InsensitiveStr::Ascii("ibilty"), + dictgen::InsensitiveStr::Ascii("ientals"), + dictgen::InsensitiveStr::Ascii("intial"), + dictgen::InsensitiveStr::Ascii("intials"), + dictgen::InsensitiveStr::Ascii("is"), + dictgen::InsensitiveStr::Ascii("ists"), + dictgen::InsensitiveStr::Ascii("itted"), + ], + values: &[ + &["created"], + &["credentials"], + &["credentials"], + &["credentials"], + &["credential"], + &["credentials"], + &["credibility"], + &["credibility"], + &["credentials"], + &["credential"], + &["credentials"], + &["credits"], + &["credits"], + &["credited"], + ], + range: 2..=8, +}; + +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("ed"), + 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("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"], &["created"], + &["created"], &["ceramic"], + &["creosote"], + &["creator"], + &["creation"], + &["create"], + &["creatable"], + &["created"], &["creatine"], + &["creating"], + &["creative"], &["creatine"], - &["creature"], + &["creature", "creator"], &["creature"], &["creatine"], &["creatine"], + &["creation", "creating"], &["creations"], &["creationism"], &["creationists"], @@ -70346,22 +133977,13 @@ pub static WORD_CRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["creatively"], &["creatively"], &["creatively"], + &["creating"], + &["create"], + &["created"], + &["creates"], &["creature"], - &["credentials"], - &["credentials"], - &["credentials"], - &["credibility"], - &["credibility"], - &["credentials"], - &["credentials"], - &["credence"], - &["creepers"], - &["creepers"], - &["creeping"], - &["creeping"], - &["cruelty"], ], - range: 4..=10, + range: 2..=9, }; static WORD_CRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70372,27 +133994,53 @@ static WORD_CRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("bine"), + dictgen::InsensitiveStr::Ascii("ce"), + dictgen::InsensitiveStr::Ascii("ches"), + dictgen::InsensitiveStr::Ascii("ete"), + dictgen::InsensitiveStr::Ascii("eting"), + dictgen::InsensitiveStr::Ascii("hed"), + dictgen::InsensitiveStr::Ascii("hes"), + dictgen::InsensitiveStr::Ascii("hs"), + dictgen::InsensitiveStr::Ascii("hses"), dictgen::InsensitiveStr::Ascii("lwed"), 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("shs"), dictgen::InsensitiveStr::Ascii("weld"), dictgen::InsensitiveStr::Ascii("yones"), ], values: &[ &["carbine"], + &["grace", "crate"], + &["crashes", "caches", "crutches"], + &["create"], + &["creating", "crating"], + &["crashed"], + &["crashes"], + &["crash", "crass"], + &["crashes"], &["crawled"], &["cranberry"], &["cranberry"], &["frankenstein"], &["croatia"], &["carpenter"], + &["crashes"], + &["crashed"], + &["crashes"], + &["crashes"], + &["crashes"], &["crawled"], &["crayons"], ], - range: 4..=9, + range: 2..=9, }; static WORD_CP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70402,11 +134050,22 @@ static WORD_CP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("oy"), + dictgen::InsensitiveStr::Ascii("pp"), ], - values: &[&["captains"], &["coy"]], - range: 2..=6, + values: &[ + &["capacities"], + &["capacity"], + &["captains"], + &["caption"], + &["coy", "copy"], + &["cpp"], + ], + range: 2..=7, }; static WORD_CO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70416,9 +134075,9 @@ static WORD_CO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_COA_NODE), - None, + Some(&WORD_COB_NODE), Some(&WORD_COC_NODE), - None, + Some(&WORD_COD_NODE), Some(&WORD_COE_NODE), Some(&WORD_COF_NODE), Some(&WORD_COG_NODE), @@ -70434,7 +134093,7 @@ static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_COR_NODE), Some(&WORD_COS_NODE), - None, + Some(&WORD_COT_NODE), Some(&WORD_COU_NODE), Some(&WORD_COV_NODE), None, @@ -70451,10 +134110,27 @@ static WORD_COY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["coyotes"]], - range: 4..=5, + values: &[ + &["coyotes"], + &["copy"], + &["copyright"], + &["copyrighted"], + &["copyrights"], + &["copyright"], + &["copyrighted"], + &["copyrights"], + &["coyotes"], + ], + range: 1..=8, }; static WORD_COV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70465,19 +134141,53 @@ static WORD_COV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("enat"), dictgen::InsensitiveStr::Ascii("enental"), + dictgen::InsensitiveStr::Ascii("ention"), + dictgen::InsensitiveStr::Ascii("entions"), + dictgen::InsensitiveStr::Ascii("ere"), + dictgen::InsensitiveStr::Ascii("eres"), + dictgen::InsensitiveStr::Ascii("erge"), + dictgen::InsensitiveStr::Ascii("erges"), + dictgen::InsensitiveStr::Ascii("erred"), + dictgen::InsensitiveStr::Ascii("ersion"), + dictgen::InsensitiveStr::Ascii("ersions"), dictgen::InsensitiveStr::Ascii("erted"), + dictgen::InsensitiveStr::Ascii("erting"), dictgen::InsensitiveStr::Ascii("nersation"), + dictgen::InsensitiveStr::Ascii("nert"), + dictgen::InsensitiveStr::Ascii("riance"), + dictgen::InsensitiveStr::Ascii("riate"), + dictgen::InsensitiveStr::Ascii("riates"), ], values: &[ &["covenant"], + &["coverage"], + &["coverages"], + &["coverage"], &["covenant"], &["covenant"], - &["converted"], + &["convention"], + &["conventions"], + &["cover"], + &["covers"], + &["coverage", "converge"], + &["coverages", "converges"], + &["covered"], + &["conversion"], + &["conversions"], + &["converted", "covered", "coveted"], + &["converting"], &["conservation"], + &["convert"], + &["covariance"], + &["covariate"], + &["covariates"], ], - range: 4..=9, + range: 3..=9, }; static WORD_COU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70498,7 +134208,7 @@ static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_COUL_NODE), - None, + Some(&WORD_COUM_NODE), Some(&WORD_COUN_NODE), None, None, @@ -70506,7 +134216,7 @@ static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_COUR_NODE), Some(&WORD_COUS_NODE), Some(&WORD_COUT_NODE), - None, + Some(&WORD_COUU_NODE), None, None, None, @@ -70514,6 +134224,17 @@ static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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, @@ -70521,6 +134242,16 @@ static WORD_COUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -70533,6 +134264,16 @@ pub static WORD_COUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ners"), ], values: &[ + &["counted"], + &["counter"], + &["countermeasure"], + &["countermeasures"], + &["countermeasure"], + &["countermeasures"], + &["counterpart"], + &["counters", "routers", "scouters"], + &["counting"], + &["counter"], &["counteract"], &["countered"], &["counterfeit"], @@ -70544,7 +134285,7 @@ pub static WORD_COUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["counterproductive"], &["counters"], ], - range: 4..=13, + range: 2..=13, }; static WORD_COUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70554,12 +134295,22 @@ static WORD_COUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["cousins"], &["cousins"], &["counselors"]], - range: 4..=6, + values: &[ + &["course", "cause"], + &["courses", "causes"], + &["cousins"], + &["cousin"], + &["cousins"], + &["counselors"], + ], + range: 1..=6, }; static WORD_COUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70569,6 +134320,7 @@ static WORD_COUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -70583,6 +134335,7 @@ pub static WORD_COUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("urier"), ], values: &[ + &["course", "coerce", "source"], &["coursework"], &["crouching"], &["coursework"], @@ -70594,9 +134347,9 @@ pub static WORD_COUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["courtroom"], &["courtroom"], &["courtesy"], - &["courier"], + &["courier", "couturier"], ], - range: 3..=7, + range: 2..=7, }; static WORD_COUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70608,6 +134361,7 @@ static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_COUNC_NODE), + Some(&WORD_COUND_NODE), None, None, None, @@ -70615,12 +134369,11 @@ static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, + Some(&WORD_COUNL_NODE), None, None, None, - None, - None, - None, + Some(&WORD_COUNP_NODE), None, Some(&WORD_COUNR_NODE), Some(&WORD_COUNS_NODE), @@ -70640,6 +134393,9 @@ static WORD_COUNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -70656,12 +134412,19 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -70672,10 +134435,15 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -70683,6 +134451,9 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("rywise"), ], values: &[ + &["contain"], + &["container"], + &["containers"], &["contains"], &["counteract"], &["counteract"], @@ -70700,11 +134471,18 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["counterfeit"], &["counterfeit"], &["counterfeit"], + &["counterfeit"], + &["counterfeits"], &["counters"], + &["countermeasure"], + &["countermeasures"], &["counterplay"], + &["counterpart"], &["counterplay"], &["counterpart"], &["counterparts"], + &["counterpart"], + &["counterparts"], &["counterpoint"], &["counterproductive"], &["counterproductive"], @@ -70715,17 +134493,22 @@ pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["counterpart"], &["counterparts"], &["counters"], - &["countries"], + &["continue"], + &["continueq", "continue"], + &["countries", "counties"], &["countering"], + &["contours", "counters"], + &["counter", "contour", "country", "county"], &["counters"], &["countryside"], + &["counters", "contours", "countries"], &["countryside"], &["countryside"], &["countering"], &["countryside"], &["countryside"], ], - range: 2..=12, + range: 1..=12, }; static WORD_COUNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70775,10 +134558,50 @@ pub static WORD_COUNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ies"), dictgen::InsensitiveStr::Ascii("tyside"), ], - values: &[&["countries"], &["countryside"]], + 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"]), +}; + +pub static WORD_COUND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ition"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[&["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, @@ -70799,8 +134622,8 @@ pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di ], values: &[ &["counseling"], - &["councillor"], - &["councillors"], + &["councillor", "counsellor", "councillor"], + &["councillors", "counsellors", "councillors"], &["counselors"], &["coincidental"], &["coincidentally"], @@ -70812,9 +134635,30 @@ pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di range: 4..=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: None, + value: Some(&["could"]), }; pub static WORD_COUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -70823,14 +134667,23 @@ pub static WORD_COUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("mns"), dictgen::InsensitiveStr::Ascii("ndt"), dictgen::InsensitiveStr::Ascii("ored"), + dictgen::InsensitiveStr::Ascii("oumb"), + dictgen::InsensitiveStr::Ascii("t"), ], - values: &[&["couldnt"], &["columns"], &["couldnt"], &["colored"]], - range: 3..=4, + values: &[ + &["couldnt"], + &["columns"], + &["couldnt"], + &["colored"], + &["coulomb"], + &["could"], + ], + range: 1..=4, }; static WORD_COUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_COUD_CHILDREN), - value: None, + value: Some(&["could"]), }; pub static WORD_COUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -70838,7 +134691,7 @@ pub static WORD_COUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("l"), dictgen::InsensitiveStr::Ascii("lnt"), ], - values: &[&["could"], &["couldnt"]], + values: &[&["could", "cloud"], &["couldnt"]], range: 1..=3, }; @@ -70853,6 +134706,59 @@ pub static WORD_COUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("rolled"), + dictgen::InsensitiveStr::Ascii("rolling"), + 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"], + &["controlled"], + &["controlling"], + &["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, @@ -70864,9 +134770,29 @@ pub static WORD_COS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("emtics"), dictgen::InsensitiveStr::Ascii("meticas"), dictgen::InsensitiveStr::Ascii("meticos"), + dictgen::InsensitiveStr::Ascii("nsrain"), + dictgen::InsensitiveStr::Ascii("nsrained"), + dictgen::InsensitiveStr::Ascii("ntrain"), + 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("titution"), dictgen::InsensitiveStr::Ascii("tomizable"), dictgen::InsensitiveStr::Ascii("tomization"), + dictgen::InsensitiveStr::Ascii("truct"), + dictgen::InsensitiveStr::Ascii("tructer"), + dictgen::InsensitiveStr::Ascii("tructor"), + dictgen::InsensitiveStr::Ascii("tum"), + dictgen::InsensitiveStr::Ascii("tumary"), dictgen::InsensitiveStr::Ascii("tumise"), dictgen::InsensitiveStr::Ascii("tumizable"), dictgen::InsensitiveStr::Ascii("tumization"), @@ -70880,18 +134806,38 @@ pub static WORD_COS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["cosmetics"], &["cosmetics"], &["cosmetics"], + &["constrain"], + &["constrained"], + &["constrain"], + &["constrains", "constraints"], + &["constraint"], + &["constraints"], + &["constructed"], + &["constructor"], + &["consumer"], + &["consolation"], + &["console"], + &["consoled"], + &["consoles"], + &["consoling"], + &["constant"], &["constitution"], &["customizable"], &["customization"], + &["construct"], + &["constructor"], + &["constructor"], + &["custom", "costume"], + &["customary"], &["costumes"], &["customizable"], &["customization"], &["customization"], &["customized"], - &["costumes"], + &["costumes", "customs"], &["costumes"], ], - range: 4..=11, + range: 3..=11, }; static WORD_COR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70903,9 +134849,9 @@ static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_CORA_NODE), None, Some(&WORD_CORC_NODE), - None, - None, - None, + Some(&WORD_CORD_NODE), + Some(&WORD_CORE_NODE), + Some(&WORD_CORF_NODE), None, None, Some(&WORD_CORI_NODE), @@ -70921,7 +134867,7 @@ static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_CORS_NODE), None, Some(&WORD_CORU_NODE), - None, + Some(&WORD_CORV_NODE), Some(&WORD_CORW_NODE), None, None, @@ -70939,15 +134885,29 @@ pub static WORD_CORW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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")], - values: &[&["crouching"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ching"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[&["crouching"], &["chorus"]], + range: 1..=5, }; static WORD_CORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70958,21 +134918,31 @@ static WORD_CORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["corsair"], + &["cursor"], &["corpses"], + &["cross", "course"], + &["crosses", "courses"], &["crossfire"], &["crosshair"], + &["crosshairs"], &["crosspost"], ], - range: 3..=5, + range: 1..=6, }; static WORD_CORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -70983,7 +134953,7 @@ static WORD_CORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_CORRA_NODE), None, - None, + Some(&WORD_CORRC_NODE), Some(&WORD_CORRD_NODE), Some(&WORD_CORRE_NODE), None, @@ -70992,14 +134962,14 @@ static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_CORRI_NODE), None, None, - None, + Some(&WORD_CORRL_NODE), None, None, Some(&WORD_CORRO_NODE), Some(&WORD_CORRP_NODE), None, - None, - None, + Some(&WORD_CORRR_NODE), + Some(&WORD_CORRS_NODE), None, Some(&WORD_CORRU_NODE), None, @@ -71018,16 +134988,70 @@ pub static WORD_CORRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), ], values: &[ &["correlates"], &["corruption"], + &["corrupted"], + &["corruptible"], + &["corruption"], &["corruption"], &["corruption"], ], - range: 3..=5, + 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("pond"), + dictgen::InsensitiveStr::Ascii("ponded"), + dictgen::InsensitiveStr::Ascii("ponding"), + dictgen::InsensitiveStr::Ascii("ponds"), + ], + values: &[ + &["correspond"], + &["corresponded"], + &["corresponding"], + &["corresponds"], + ], + range: 4..=7, +}; + +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("esponding"), + dictgen::InsensitiveStr::Ascii("esponds"), + dictgen::InsensitiveStr::Ascii("upt"), + dictgen::InsensitiveStr::Ascii("upted"), + dictgen::InsensitiveStr::Ascii("uption"), + ], + values: &[ + &["correct"], + &["corrected"], + &["corresponding"], + &["corresponds"], + &["corrupt"], + &["corrupted"], + &["corruption"], + ], + range: 3..=9, }; static WORD_CORRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -71051,6 +135075,7 @@ pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("lated"), dictgen::InsensitiveStr::Ascii("lates"), dictgen::InsensitiveStr::Ascii("lation"), + dictgen::InsensitiveStr::Ascii("lations"), dictgen::InsensitiveStr::Ascii("spond"), dictgen::InsensitiveStr::Ascii("spondence"), dictgen::InsensitiveStr::Ascii("sponding"), @@ -71060,6 +135085,7 @@ pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["correlated"], &["correlates"], &["correlation"], + &["correlations"], &["correspond"], &["correspondence"], &["corresponding"], @@ -71068,6 +135094,20 @@ pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -71076,6 +135116,7 @@ static WORD_CORRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -71089,6 +135130,7 @@ pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di ], values: &[ &["corridor"], + &["corridors"], &["correlated"], &["correlates"], &["correlation"], @@ -71104,56 +135146,338 @@ pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_CORRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CORRE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CORRE_CHILDREN), value: None, }; -pub static WORD_CORRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ccion"), - dictgen::InsensitiveStr::Ascii("citon"), - dictgen::InsensitiveStr::Ascii("clty"), - dictgen::InsensitiveStr::Ascii("cters"), - dictgen::InsensitiveStr::Ascii("ctess"), - dictgen::InsensitiveStr::Ascii("ctin"), - dictgen::InsensitiveStr::Ascii("ctings"), - dictgen::InsensitiveStr::Ascii("ctionals"), - dictgen::InsensitiveStr::Ascii("ctivo"), - dictgen::InsensitiveStr::Ascii("ctivos"), - dictgen::InsensitiveStr::Ascii("ctons"), - dictgen::InsensitiveStr::Ascii("cty"), - dictgen::InsensitiveStr::Ascii("gated"), - dictgen::InsensitiveStr::Ascii("kting"), - dictgen::InsensitiveStr::Ascii("ktions"), - dictgen::InsensitiveStr::Ascii("ktness"), - dictgen::InsensitiveStr::Ascii("lacion"), - dictgen::InsensitiveStr::Ascii("latas"), - dictgen::InsensitiveStr::Ascii("latie"), - dictgen::InsensitiveStr::Ascii("laties"), - dictgen::InsensitiveStr::Ascii("lato"), - dictgen::InsensitiveStr::Ascii("latos"), - dictgen::InsensitiveStr::Ascii("nti"), - dictgen::InsensitiveStr::Ascii("ponding"), - dictgen::InsensitiveStr::Ascii("posding"), - dictgen::InsensitiveStr::Ascii("psondence"), - dictgen::InsensitiveStr::Ascii("psonding"), - dictgen::InsensitiveStr::Ascii("spend"), - dictgen::InsensitiveStr::Ascii("spondant"), - dictgen::InsensitiveStr::Ascii("spondants"), - dictgen::InsensitiveStr::Ascii("spondece"), - dictgen::InsensitiveStr::Ascii("spondense"), - dictgen::InsensitiveStr::Ascii("spondente"), - dictgen::InsensitiveStr::Ascii("sponders"), - dictgen::InsensitiveStr::Ascii("spondes"), - dictgen::InsensitiveStr::Ascii("spondig"), - dictgen::InsensitiveStr::Ascii("sponing"), - dictgen::InsensitiveStr::Ascii("sponsing"), - dictgen::InsensitiveStr::Ascii("tly"), + 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("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("pondance"), + dictgen::InsensitiveStr::Ascii("pondances"), + dictgen::InsensitiveStr::Ascii("pondant"), + dictgen::InsensitiveStr::Ascii("pondants"), + 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("ponging"), + dictgen::InsensitiveStr::Ascii("poning"), + 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"], + &["correspond"], + &["corresponding"], + &["corresponding"], + &["corresponding"], + &["correspondence"], + &["corresponding"], + &["corresponding"], + &["correspond"], + &["corresponded"], + &["correspondence"], + &["correspondences"], + &["correspondent"], + &["correspondents"], + &["corresponding"], + &["corresponds"], + &["correspondence"], + &["correspondences"], + &["correspondent"], + &["correspondents"], + &["correspondence"], + &["correspondent"], + &["correspondence"], + &["correspondence"], + &["corresponds"], + &["corresponds"], + &["corresponding"], + &["corresponding"], + &["corresponding"], + &["corresponding"], + &["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"), + ], + values: &[ + &["correspond"], + &["corresponded"], + &["correspondence"], + &["correspondences"], + &["correspondent"], + &["correspondents"], + &["corresponding"], + &["corresponds"], + &["correct", "current"], + &["correcting"], + ], + 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"), + ], + values: &[&["correct"], &["correctly"]], + range: 2..=4, +}; + +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("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("tnes"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tons"), + dictgen::InsensitiveStr::Ascii("tures"), + dictgen::InsensitiveStr::Ascii("ty"), + dictgen::InsensitiveStr::Ascii("tyly"), + dictgen::InsensitiveStr::Ascii("xt"), ], values: &[ &["correction"], &["corrections"], &["correctly"], + &["correctly"], + &["correctable"], + &["correctly"], &["correctors"], &["correctness"], &["correction"], @@ -71161,37 +135485,15 @@ pub static WORD_CORRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["corrections"], &["correction"], &["corrections"], - &["corrections"], - &["correctly"], - &["correlated"], - &["correcting"], - &["corrections"], &["correctness"], - &["correlation"], - &["correlates"], - &["correlated"], - &["correlates"], - &["correlation"], - &["correlates"], - &["correcting"], - &["corresponding"], - &["corresponding"], - &["correspondence"], - &["corresponding"], - &["correspond"], - &["correspondent"], - &["correspondents"], - &["correspondence"], - &["correspondence"], - &["correspondence"], - &["corresponds"], - &["corresponds"], - &["corresponding"], - &["corresponding"], - &["corresponding"], + &["correction"], + &["corrections"], + &["correctors"], &["correctly"], + &["correctly"], + &["correct"], ], - range: 3..=9, + range: 2..=7, }; static WORD_CORRD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -71201,13 +135503,28 @@ static WORD_CORRD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_CORRD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("inates"), dictgen::InsensitiveStr::Ascii("ination"), dictgen::InsensitiveStr::Ascii("ior"), ], - values: &[&["coordination"], &["corridor"]], + values: &[&["coordinates"], &["coordination"], &["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, @@ -71239,8 +135556,11 @@ pub static WORD_CORP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("oratie"), dictgen::InsensitiveStr::Ascii("orativo"), dictgen::InsensitiveStr::Ascii("orativos"), + 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: &[ @@ -71253,11 +135573,14 @@ pub static WORD_CORP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["corporate"], &["corporation"], &["corporations"], + &["corporation"], &["corporate"], &["corporations"], + &["corporation"], + &["corporations"], &["corpses"], ], - range: 4..=8, + range: 4..=9, }; static WORD_CORO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -71269,10 +135592,36 @@ pub static WORD_CORO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["corrosion"]], - range: 4..=4, + 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 { @@ -71306,6 +135655,7 @@ pub static WORD_CORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("nthinans"), dictgen::InsensitiveStr::Ascii("nthinas"), dictgen::InsensitiveStr::Ascii("nthins"), + dictgen::InsensitiveStr::Ascii("spond"), ], values: &[ &["cordial"], @@ -71318,10 +135668,102 @@ pub static WORD_CORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["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("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"], + &["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("inate"), + dictgen::InsensitiveStr::Ascii("inates"), + dictgen::InsensitiveStr::Ascii("oroy"), + dictgen::InsensitiveStr::Ascii("ump"), + ], + values: &[ + &["coordinate"], + &["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, @@ -71340,172 +135782,730 @@ static WORD_CORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["carolina"], &["corsair"], &["croatia"]], - range: 3..=4, + values: &[&["chorale"], &["carolina"], &["corsair"], &["croatia"]], + range: 2..=4, }; static WORD_COP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_COP_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_COP_CHILDREN), value: None, }; -pub static WORD_COP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ehnagen"), - dictgen::InsensitiveStr::Ascii("enaghen"), - dictgen::InsensitiveStr::Ascii("enahgen"), - dictgen::InsensitiveStr::Ascii("engagen"), - dictgen::InsensitiveStr::Ascii("engahen"), - dictgen::InsensitiveStr::Ascii("enhaagen"), - dictgen::InsensitiveStr::Ascii("enhaegen"), - dictgen::InsensitiveStr::Ascii("enhagan"), - dictgen::InsensitiveStr::Ascii("enhagn"), - dictgen::InsensitiveStr::Ascii("enhague"), - dictgen::InsensitiveStr::Ascii("enhaguen"), - dictgen::InsensitiveStr::Ascii("enhagun"), - dictgen::InsensitiveStr::Ascii("enhangen"), - dictgen::InsensitiveStr::Ascii("enhaven"), - dictgen::InsensitiveStr::Ascii("enhegan"), - dictgen::InsensitiveStr::Ascii("metitors"), - dictgen::InsensitiveStr::Ascii("rorate"), - dictgen::InsensitiveStr::Ascii("roration"), - dictgen::InsensitiveStr::Ascii("rorations"), - dictgen::InsensitiveStr::Ascii("rses"), - dictgen::InsensitiveStr::Ascii("uter"), - dictgen::InsensitiveStr::Ascii("yrighed"), - dictgen::InsensitiveStr::Ascii("yrigted"), - dictgen::InsensitiveStr::Ascii("yrigthed"), - dictgen::InsensitiveStr::Ascii("ywrite"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("eight"), + dictgen::InsensitiveStr::Ascii("eighted"), + dictgen::InsensitiveStr::Ascii("eights"), + dictgen::InsensitiveStr::Ascii("ied"), + 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: &[ - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["copenhagen"], - &["competitors"], - &["corporate"], - &["corporation"], - &["corporations"], - &["corpses"], - &["computer"], + &["copied"], + &["copyright"], &["copyrighted"], + &["copyrights"], + &["copied"], &["copyrighted"], &["copyrighted"], &["copyright"], + &["copyrighted"], + &["copyrights"], + &["copyright"], + &["copyrighted"], + &["copyrights"], + &["copyright"], + &["copyrighted"], + &["copyrights"], + &["copies"], + &["copyright"], + &["copyrighted"], + &["copyrights"], + &["copying"], + &["copyright"], ], - range: 4..=9, + range: 1..=8, }; -static WORD_COO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_COO_CHILDREN), +static WORD_COPV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_COPV_CHILDREN), value: None, }; -pub static WORD_COO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ldows"), - dictgen::InsensitiveStr::Ascii("ldwons"), - dictgen::InsensitiveStr::Ascii("peracion"), - dictgen::InsensitiveStr::Ascii("perativo"), - dictgen::InsensitiveStr::Ascii("peratve"), - dictgen::InsensitiveStr::Ascii("poration"), - dictgen::InsensitiveStr::Ascii("porative"), - dictgen::InsensitiveStr::Ascii("rdenate"), - dictgen::InsensitiveStr::Ascii("rdenated"), - dictgen::InsensitiveStr::Ascii("rdenates"), - dictgen::InsensitiveStr::Ascii("rdenation"), - dictgen::InsensitiveStr::Ascii("rdiante"), - dictgen::InsensitiveStr::Ascii("rdianted"), - dictgen::InsensitiveStr::Ascii("rdiantes"), - dictgen::InsensitiveStr::Ascii("rdiantion"), - dictgen::InsensitiveStr::Ascii("rdiantor"), - dictgen::InsensitiveStr::Ascii("rdinacion"), - dictgen::InsensitiveStr::Ascii("rdinador"), - dictgen::InsensitiveStr::Ascii("rdinants"), - dictgen::InsensitiveStr::Ascii("rdinar"), - dictgen::InsensitiveStr::Ascii("rdinare"), - dictgen::InsensitiveStr::Ascii("rdinater"), - dictgen::InsensitiveStr::Ascii("rdinaters"), - dictgen::InsensitiveStr::Ascii("rdinatior"), - dictgen::InsensitiveStr::Ascii("rdinato"), - dictgen::InsensitiveStr::Ascii("rdinaton"), - dictgen::InsensitiveStr::Ascii("rdinatore"), - dictgen::InsensitiveStr::Ascii("rdinats"), - dictgen::InsensitiveStr::Ascii("rdine"), - dictgen::InsensitiveStr::Ascii("rdonate"), - dictgen::InsensitiveStr::Ascii("rdonated"), - dictgen::InsensitiveStr::Ascii("rdonates"), - dictgen::InsensitiveStr::Ascii("rdonation"), - dictgen::InsensitiveStr::Ascii("rdonator"), - dictgen::InsensitiveStr::Ascii("responding"), - dictgen::InsensitiveStr::Ascii("ridnate"), - dictgen::InsensitiveStr::Ascii("ridnated"), - dictgen::InsensitiveStr::Ascii("ridnates"), - dictgen::InsensitiveStr::Ascii("ridnation"), - dictgen::InsensitiveStr::Ascii("ridnator"), - dictgen::InsensitiveStr::Ascii("rperation"), - dictgen::InsensitiveStr::Ascii("rperations"), + 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: &[ + &["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("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"], + &["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("ying"), + ], + values: &[&["component"], &["copying"]], + range: 4..=4, +}; + +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("utations"), + ], + values: &[ + &["competitors"], + &["compilation"], + &["component"], + &["computations"], + ], + range: 5..=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("etely")], + values: &[&["completely"]], + range: 5..=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("ese"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ler"), + ], + values: &[&["copies"], &["copying"], &["compiler"]], + range: 3..=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), + None, + None, + Some(&WORD_COOG_NODE), + None, + None, + None, + Some(&WORD_COOK_NODE), + Some(&WORD_COOL_NODE), + Some(&WORD_COOM_NODE), + Some(&WORD_COON_NODE), + None, + 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("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("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"], + &["coordinate"], + &["coordinated"], + &["coordinates"], + &["coordination"], + &["coordinate"], + &["coordinated"], + &["coordinates"], + &["coordination"], + &["coordinator"], + &["coordinate"], + &["coordinates"], + &["coordinates"], + &["coordination"], + &["coordinator"], + &["coordinates"], + &["coordinator"], + &["coordinate"], + &["coordinator"], + &["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("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: &[ + &["cooperate"], + &["cooperates"], + &["cooperation"], + &["cooperation"], + &["cooperative"], + &["cooperation"], + &["cooperative"], + ], + range: 5..=7, +}; + +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"), + ], + values: &[&["command"], &["command"]], + range: 3..=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"], - &["cooperation"], - &["cooperation"], - &["cooperative"], - &["cooperation"], - &["cooperative"], - &["coordinate"], - &["coordinated"], - &["coordinates"], - &["coordination"], - &["coordinate"], - &["coordinated"], - &["coordinates"], - &["coordination"], - &["coordinator"], - &["coordination"], - &["coordinator"], - &["coordinates"], - &["coordinator"], - &["coordinate"], - &["coordinator"], - &["coordinates"], - &["coordinator"], - &["coordination"], - &["coordination"], - &["coordinate"], - &["coordinates"], - &["coordinate"], - &["coordinate"], - &["coordinated"], - &["coordinates"], - &["coordination"], - &["coordinator"], - &["corresponding"], - &["coordinate"], - &["coordinated"], - &["coordinates"], - &["coordination"], - &["coordinator"], - &["cooperation"], - &["corporations"], + &["coolant"], + &["culotte"], + &["culottes"], ], - range: 5..=10, + 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_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 { @@ -71526,22 +136526,33 @@ static WORD_CON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_CONJ_NODE), None, Some(&WORD_CONL_NODE), - None, + Some(&WORD_CONM_NODE), Some(&WORD_CONN_NODE), Some(&WORD_CONO_NODE), Some(&WORD_CONP_NODE), Some(&WORD_CONQ_NODE), - None, + Some(&WORD_CONR_NODE), Some(&WORD_CONS_NODE), Some(&WORD_CONT_NODE), - None, + Some(&WORD_CONU_NODE), Some(&WORD_CONV_NODE), None, 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, @@ -71596,9 +136607,12 @@ static WORD_CONVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_CONVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("eration")], - values: &[&["conservation"]], - range: 7..=7, + keys: &[ + dictgen::InsensitiveStr::Ascii("eration"), + dictgen::InsensitiveStr::Ascii("erion"), + ], + values: &[&["conservation"], &["conversion"]], + range: 5..=7, }; static WORD_CONVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -71612,14 +136626,20 @@ pub static WORD_CONVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("rsation"), dictgen::InsensitiveStr::Ascii("rsations"), dictgen::InsensitiveStr::Ascii("ulted"), + dictgen::InsensitiveStr::Ascii("vle"), + dictgen::InsensitiveStr::Ascii("vled"), + dictgen::InsensitiveStr::Ascii("vling"), ], values: &[ &["convoluted"], &["conversation"], &["conversations"], &["convoluted"], + &["convolve"], + &["convolved"], + &["convolving"], ], - range: 5..=8, + range: 3..=8, }; static WORD_CONVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -71634,21 +136654,49 @@ pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("citon"), dictgen::InsensitiveStr::Ascii("citons"), dictgen::InsensitiveStr::Ascii("cto"), + dictgen::InsensitiveStr::Ascii("ence"), 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("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"], @@ -71656,23 +136704,51 @@ pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["conviction"], &["convictions"], &["conviction"], + &["convince", "convenience"], &["convenience"], &["convenient"], &["conveniently"], + &["convenience"], &["convenient"], + &["conveniently"], + &["configuration"], + &["configure"], &["convoluted"], + &["combination"], &["convincing"], &["convenient"], &["convinces"], &["convince"], - &["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..=7, + range: 2..=8, }; static WORD_CONVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -71700,11 +136776,11 @@ static WORD_CONVE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, Some(&WORD_CONVER_NODE), Some(&WORD_CONVES_NODE), + Some(&WORD_CONVET_NODE), None, None, None, - None, - None, + Some(&WORD_CONVEX_NODE), Some(&WORD_CONVEY_NODE), None, ]; @@ -71723,136 +136799,348 @@ pub static WORD_CONVEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("s"), + ], + values: &[ + &["converted"], + &["converter"], + &["converters"], + &["converting"], + &["convention"], + &["converts"], + ], + range: 1..=3, +}; + 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("ration")], - values: &[&["conservation"]], - range: 6..=6, + 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::Flat(&WORD_CONVER_CHILDREN), + 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_CONVER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[ - dictgen::InsensitiveStr::Ascii("astion"), - dictgen::InsensitiveStr::Ascii("astions"), - dictgen::InsensitiveStr::Ascii("dation"), - dictgen::InsensitiveStr::Ascii("esly"), - dictgen::InsensitiveStr::Ascii("gens"), - dictgen::InsensitiveStr::Ascii("ison"), - dictgen::InsensitiveStr::Ascii("itble"), - dictgen::InsensitiveStr::Ascii("ning"), - dictgen::InsensitiveStr::Ascii("s"), - dictgen::InsensitiveStr::Ascii("sacion"), - dictgen::InsensitiveStr::Ascii("sacional"), - dictgen::InsensitiveStr::Ascii("saion"), - dictgen::InsensitiveStr::Ascii("saiton"), - dictgen::InsensitiveStr::Ascii("sare"), - dictgen::InsensitiveStr::Ascii("satin"), - dictgen::InsensitiveStr::Ascii("satino"), - dictgen::InsensitiveStr::Ascii("sationa"), - dictgen::InsensitiveStr::Ascii("sationable"), - dictgen::InsensitiveStr::Ascii("sationg"), - dictgen::InsensitiveStr::Ascii("sationy"), - dictgen::InsensitiveStr::Ascii("satiosn"), - dictgen::InsensitiveStr::Ascii("satism"), - dictgen::InsensitiveStr::Ascii("satives"), - dictgen::InsensitiveStr::Ascii("satoin"), - dictgen::InsensitiveStr::Ascii("seley"), - dictgen::InsensitiveStr::Ascii("sie"), - dictgen::InsensitiveStr::Ascii("sin"), - dictgen::InsensitiveStr::Ascii("sino"), - dictgen::InsensitiveStr::Ascii("siones"), - dictgen::InsensitiveStr::Ascii("sley"), - dictgen::InsensitiveStr::Ascii("soin"), - dictgen::InsensitiveStr::Ascii("sons"), - dictgen::InsensitiveStr::Ascii("st"), - dictgen::InsensitiveStr::Ascii("staion"), - dictgen::InsensitiveStr::Ascii("staional"), - dictgen::InsensitiveStr::Ascii("staions"), - dictgen::InsensitiveStr::Ascii("stion"), - dictgen::InsensitiveStr::Ascii("tables"), - dictgen::InsensitiveStr::Ascii("tiable"), - dictgen::InsensitiveStr::Ascii("tibile"), - dictgen::InsensitiveStr::Ascii("tie"), - dictgen::InsensitiveStr::Ascii("tion"), - dictgen::InsensitiveStr::Ascii("tire"), - dictgen::InsensitiveStr::Ascii("tirea"), - dictgen::InsensitiveStr::Ascii("tirle"), - dictgen::InsensitiveStr::Ascii("tirme"), - dictgen::InsensitiveStr::Ascii("tirte"), - dictgen::InsensitiveStr::Ascii("tis"), - dictgen::InsensitiveStr::Ascii("tr"), - dictgen::InsensitiveStr::Ascii("vation"), - dictgen::InsensitiveStr::Ascii("vatism"), - dictgen::InsensitiveStr::Ascii("ying"), - dictgen::InsensitiveStr::Ascii("zation"), - ], - values: &[ - &["conversations"], - &["conservation"], - &["conservation"], - &["conversely"], - &["converse"], - &["conversions"], - &["convertible"], - &["converting"], - &["converts"], - &["conversation"], - &["conversational"], - &["conversion"], - &["conversations"], - &["converse"], - &["conversations"], - &["conservation"], - &["conservation"], - &["conversational"], - &["conservation"], - &["conservation"], - &["conservation"], - &["conservatism"], - &["conservatives"], - &["conversations"], - &["conversely"], - &["converse"], - &["conversions"], - &["conversions"], - &["conversions"], - &["conversely"], - &["conversions"], - &["conversions"], - &["converts"], - &["conversation"], - &["conversational"], - &["conversations"], - &["conversion"], - &["convertibles"], - &["convertible"], - &["convertible"], - &["convertible"], - &["conversion"], - &["converter"], - &["converter"], - &["convertible"], - &["converter"], - &["converter"], - &["converts"], - &["converter"], - &["conservation"], - &["conservatism"], - &["converting"], - &["conservation"], - ], - range: 1..=10, +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("ation"), + dictgen::InsensitiveStr::Ascii("atism"), + ], + values: &[&["conservation"], &["conservatism"]], + range: 5..=5, + }; + +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("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"], + &["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("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"), + ], + 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"], + &["conversions"], + &["conversion"], + &["converts", "convert"], + &["conversation"], + &["conversational"], + &["conversations"], + &["conversion", "conversation"], + &["conversions", "conversations"], + ], + 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("stion"), + dictgen::InsensitiveStr::Ascii("stions"), + ], + values: &[&["conversations"], &["conservation"]], + range: 5..=6, + }; + static WORD_CONVEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CONVEN_CHILDREN), value: None, @@ -71864,6 +137152,7 @@ pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("cen"), dictgen::InsensitiveStr::Ascii("cion"), dictgen::InsensitiveStr::Ascii("cional"), + dictgen::InsensitiveStr::Ascii("ction"), dictgen::InsensitiveStr::Ascii("eince"), dictgen::InsensitiveStr::Ascii("iance"), dictgen::InsensitiveStr::Ascii("iant"), @@ -71873,17 +137162,23 @@ pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("iet"), dictgen::InsensitiveStr::Ascii("ietly"), dictgen::InsensitiveStr::Ascii("ince"), + dictgen::InsensitiveStr::Ascii("inent"), 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"], + &["convention", "convection"], &["convenience"], &["convenience"], &["convenient"], @@ -71894,10 +137189,15 @@ pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["conveniently"], &["convenience"], &["convenient"], + &["convenient"], + &["convince"], + &["convention", "conversion"], &["conventional"], + &["convenient"], &["conventional"], &["conventional"], &["convention"], + &["convenient"], ], range: 2..=7, }; @@ -71923,8 +137223,16 @@ pub static WORD_CONVEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("nence"), dictgen::InsensitiveStr::Ascii("nent"), dictgen::InsensitiveStr::Ascii("nently"), + dictgen::InsensitiveStr::Ascii("nience"), + dictgen::InsensitiveStr::Ascii("nient"), + ], + values: &[ + &["convenience"], + &["convenient"], + &["conveniently"], + &["convenience"], + &["convenient"], ], - values: &[&["convenience"], &["convenient"], &["conveniently"]], range: 4..=6, }; @@ -71945,9 +137253,37 @@ static WORD_CONVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_CONVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("luted")], - values: &[&["convoluted"]], - range: 5..=5, + 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 { @@ -71969,7 +137305,7 @@ static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, None, - None, + Some(&WORD_CONTN_NODE), Some(&WORD_CONTO_NODE), None, None, @@ -71981,9 +137317,20 @@ static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str 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, @@ -71993,9 +137340,10 @@ pub static WORD_CONTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("ining"), dictgen::InsensitiveStr::Ascii("inity"), + dictgen::InsensitiveStr::Ascii("r"), ], - values: &[&["continuing"], &["continuity"]], - range: 5..=5, + values: &[&["continuing"], &["continuity"], &["contour"]], + range: 1..=5, }; static WORD_CONTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72004,9 +137352,23 @@ static WORD_CONTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_CONTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("truction")], - values: &[&["construction"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("ruction"), + dictgen::InsensitiveStr::Ascii("tant"), + dictgen::InsensitiveStr::Ascii("tants"), + dictgen::InsensitiveStr::Ascii("traint"), + dictgen::InsensitiveStr::Ascii("tructing"), + dictgen::InsensitiveStr::Ascii("truction"), + ], + values: &[ + &["construction"], + &["constant"], + &["constants"], + &["constraint"], + &["constructing"], + &["construction"], + ], + range: 4..=8, }; static WORD_CONTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72026,7 +137388,7 @@ static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st Some(&WORD_CONTRI_NODE), None, None, - None, + Some(&WORD_CONTRL_NODE), None, None, Some(&WORD_CONTRO_NODE), @@ -72034,15 +137396,26 @@ static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, None, None, - None, + Some(&WORD_CONTRT_NODE), Some(&WORD_CONTRU_NODE), None, 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, @@ -72053,26 +137426,45 @@ pub static WORD_CONTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], - &["contracting"], + &["construct"], + &["constructed"], + &["contracting", "constructing"], &["construction"], - &["contractions"], - &["contractors"], + &["contractions", "constructions"], + &["constructor"], + &["contractors", "constructors"], + &["constructs"], ], - range: 4..=6, + 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_CONTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CONTRO_CHILDREN), - value: None, + value: Some(&["control"]), }; pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -72082,19 +137474,27 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("lllers"), + dictgen::InsensitiveStr::Ascii("llor"), dictgen::InsensitiveStr::Ascii("llore"), dictgen::InsensitiveStr::Ascii("lls"), + dictgen::InsensitiveStr::Ascii("nl"), + dictgen::InsensitiveStr::Ascii("oler"), dictgen::InsensitiveStr::Ascii("vercial"), dictgen::InsensitiveStr::Ascii("vercy"), dictgen::InsensitiveStr::Ascii("verial"), @@ -72104,6 +137504,7 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -72115,19 +137516,27 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["contradicting"], &["contradiction"], &["contradictions"], + &["controllable"], &["controls"], + &["control", "controlled", "controller"], &["controlled"], &["controllers"], - &["controls"], - &["controls"], + &["controllers"], + &["controller"], + &["controls", "controllers"], + &["controls", "controllers"], &["controllers"], &["controlling"], &["control"], &["controllers"], + &["controlled"], &["controls"], &["controllers"], + &["controller"], &["controllers"], &["controls"], + &["control"], + &["controller"], &["controversial"], &["controversy"], &["controversial"], @@ -72137,6 +137546,7 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["controversial"], &["controversy"], &["controversy"], + &["controversial"], &["controversy"], &["controversial"], &["controversy"], @@ -72145,6 +137555,17 @@ pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -72187,8 +137608,14 @@ pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("dicted"), dictgen::InsensitiveStr::Ascii("dictory"), dictgen::InsensitiveStr::Ascii("dicts"), + dictgen::InsensitiveStr::Ascii("es"), 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"), ], @@ -72228,12 +137655,18 @@ pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["contradicted"], &["contradictory"], &["contradicts"], + &["countries"], &["contributions"], + &["contributes", "contribute"], + &["contributed"], &["contributes"], + &["contributing"], + &["contribution"], + &["contributions"], &["controversial"], &["controversy"], ], - range: 3..=8, + range: 2..=8, }; static WORD_CONTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72269,15 +137702,21 @@ pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -72295,8 +137734,14 @@ pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("dicton"), dictgen::InsensitiveStr::Ascii("dictons"), dictgen::InsensitiveStr::Ascii("dtion"), + dictgen::InsensitiveStr::Ascii("ined"), + dictgen::InsensitiveStr::Ascii("ining"), + dictgen::InsensitiveStr::Ascii("int"), + dictgen::InsensitiveStr::Ascii("ints"), + dictgen::InsensitiveStr::Ascii("itns"), dictgen::InsensitiveStr::Ascii("ticted"), dictgen::InsensitiveStr::Ascii("ticting"), + dictgen::InsensitiveStr::Ascii("veining"), dictgen::InsensitiveStr::Ascii("vercial"), dictgen::InsensitiveStr::Ascii("versial"), dictgen::InsensitiveStr::Ascii("versy"), @@ -72307,15 +137752,21 @@ pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["contraceptives"], &["contraception"], &["contraceptives"], + &["contradiction"], + &["contradictions"], &["contracting"], + &["contradiction"], + &["contradictions"], &["contractor"], &["contracts"], &["contractor"], &["contractor"], + &["contractors"], &["contraction"], &["contraction"], &["contracts"], &["contradicted"], + &["contradictory"], &["contradiction"], &["contradicted"], &["contradicts"], @@ -72333,8 +137784,14 @@ pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["contradiction"], &["contradicts"], &["contraction"], + &["contained", "constrained"], + &["constraining"], + &["constraint"], + &["constraints"], + &["constraints"], &["contradicted"], &["contradicting"], + &["contravening"], &["controversial"], &["controversial"], &["controversy"], @@ -72348,9 +137805,46 @@ static WORD_CONTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_CONTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rller")], - values: &[&["controllers"]], - range: 5..=5, + 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("t")], + values: &[&["content"]], + range: 1..=1, }; static WORD_CONTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72394,6 +137888,10 @@ static WORD_CONTIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -72401,13 +137899,17 @@ pub static WORD_CONTIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("nity"), ], values: &[ + &["continuation"], + &["continue"], + &["contiguous"], + &["continuing"], &["continual"], &["continually"], &["continuation"], &["containing"], &["continuity"], ], - range: 3..=6, + range: 1..=6, }; static WORD_CONTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72437,142 +137939,273 @@ pub static WORD_CONTIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d }; static WORD_CONTIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONTIN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONTIN_CHILDREN), value: None, }; -pub static WORD_CONTIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[ - dictgen::InsensitiveStr::Ascii("ant"), - dictgen::InsensitiveStr::Ascii("ants"), - dictgen::InsensitiveStr::Ascii("e"), - dictgen::InsensitiveStr::Ascii("ed"), - dictgen::InsensitiveStr::Ascii("enal"), - dictgen::InsensitiveStr::Ascii("enet"), - dictgen::InsensitiveStr::Ascii("enets"), - dictgen::InsensitiveStr::Ascii("ens"), - dictgen::InsensitiveStr::Ascii("entais"), - dictgen::InsensitiveStr::Ascii("entes"), - dictgen::InsensitiveStr::Ascii("ential"), - dictgen::InsensitiveStr::Ascii("entul"), - dictgen::InsensitiveStr::Ascii("eous"), - dictgen::InsensitiveStr::Ascii("eously"), - dictgen::InsensitiveStr::Ascii("es"), - dictgen::InsensitiveStr::Ascii("etal"), - dictgen::InsensitiveStr::Ascii("gancy"), - dictgen::InsensitiveStr::Ascii("gecy"), - dictgen::InsensitiveStr::Ascii("geny"), - dictgen::InsensitiveStr::Ascii("gient"), - dictgen::InsensitiveStr::Ascii("gincy"), - dictgen::InsensitiveStr::Ascii("ient"), - dictgen::InsensitiveStr::Ascii("ious"), - dictgen::InsensitiveStr::Ascii("iously"), - dictgen::InsensitiveStr::Ascii("iuty"), - dictgen::InsensitiveStr::Ascii("ous"), - dictgen::InsensitiveStr::Ascii("ously"), - dictgen::InsensitiveStr::Ascii("tent"), - dictgen::InsensitiveStr::Ascii("uacion"), - dictgen::InsensitiveStr::Ascii("ualy"), - dictgen::InsensitiveStr::Ascii("uare"), - dictgen::InsensitiveStr::Ascii("uarla"), - dictgen::InsensitiveStr::Ascii("uarlo"), - dictgen::InsensitiveStr::Ascii("uasse"), - dictgen::InsensitiveStr::Ascii("uati"), - dictgen::InsensitiveStr::Ascii("uating"), - dictgen::InsensitiveStr::Ascii("uativo"), - dictgen::InsensitiveStr::Ascii("uato"), - dictgen::InsensitiveStr::Ascii("ueing"), - dictgen::InsensitiveStr::Ascii("uemos"), - dictgen::InsensitiveStr::Ascii("uent"), - dictgen::InsensitiveStr::Ascii("ueous"), - dictgen::InsensitiveStr::Ascii("uety"), - dictgen::InsensitiveStr::Ascii("uining"), - dictgen::InsensitiveStr::Ascii("uious"), - dictgen::InsensitiveStr::Ascii("um"), - dictgen::InsensitiveStr::Ascii("unes"), - dictgen::InsensitiveStr::Ascii("uning"), - dictgen::InsensitiveStr::Ascii("unity"), - dictgen::InsensitiveStr::Ascii("uons"), - dictgen::InsensitiveStr::Ascii("uos"), - dictgen::InsensitiveStr::Ascii("uosly"), - dictgen::InsensitiveStr::Ascii("us"), - dictgen::InsensitiveStr::Ascii("ut"), - dictgen::InsensitiveStr::Ascii("ute"), - dictgen::InsensitiveStr::Ascii("uting"), - dictgen::InsensitiveStr::Ascii("utity"), - dictgen::InsensitiveStr::Ascii("utiy"), - dictgen::InsensitiveStr::Ascii("uu"), - dictgen::InsensitiveStr::Ascii("uuing"), - dictgen::InsensitiveStr::Ascii("uuity"), - dictgen::InsensitiveStr::Ascii("uuum"), - ], - values: &[ - &["continental"], - &["continents"], - &["continue"], - &["continued"], - &["continental"], - &["continents"], - &["continents"], - &["continents"], - &["continents"], - &["continents"], - &["continental"], - &["continental"], - &["continuous"], - &["continuously"], - &["continents"], - &["continental"], - &["contingency"], - &["contingency"], - &["contingency"], - &["contingent"], - &["contingency"], - &["contingent"], - &["continuous"], - &["continuously"], - &["continuity"], - &["continuous"], - &["continuously"], - &["contingent"], - &["continuation"], - &["continually"], - &["continue"], - &["continual"], - &["continual"], - &["continues"], - &["continuity"], - &["continuation"], - &["continuation"], - &["continuation"], - &["continuing"], - &["continues"], - &["contingent"], - &["continuous"], - &["continuity"], - &["continuing"], - &["continuous"], - &["continuum"], - &["continents"], - &["continuing"], - &["continuity"], - &["continuous"], - &["continuous"], - &["continuously"], - &["continues"], - &["continuity"], - &["continue"], - &["continuing"], - &["continuity"], - &["continuity"], - &["continuous"], - &["continuing"], - &["continuity"], - &["continuum"], - ], - range: 1..=6, +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, + None, + 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("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("os"), + dictgen::InsensitiveStr::Ascii("osly"), + dictgen::InsensitiveStr::Ascii("re"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("sly"), + dictgen::InsensitiveStr::Ascii("t"), + 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"], + &["continuity"], + &["continuing"], + &["continuous"], + &["continuum"], + &["continents"], + &["continuing"], + &["continuity"], + &["continuous"], + &["continuous"], + &["continuously"], + &["continue"], + &["continues", "continue", "continuous"], + &["continues"], + &["continuously"], + &["continuity"], + &["continue"], + &["continuing"], + &["continuity"], + &["continuity"], + &["continuous"], + &["continuing"], + &["continuity"], + &["continuum"], + ], + range: 1..=5, + }; + +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_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("us"), + dictgen::InsensitiveStr::Ascii("usly"), + ], + values: &[&["continue"], &["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("ous"), + dictgen::InsensitiveStr::Ascii("ously"), + dictgen::InsensitiveStr::Ascii("uty"), + ], + values: &[ + &["contingent"], + &["continuous"], + &["continuously"], + &["continuity"], + ], + range: 3..=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, @@ -72597,15 +138230,27 @@ pub static WORD_CONTIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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("uities"), + dictgen::InsensitiveStr::Ascii("uos"), ], values: &[ &["contingent"], &["continents"], - &["contagious"], + &["contagious", "contiguous"], + &["contiguously"], &["contingent"], + &["contiguous"], + &["contiguous"], + &["contiguous"], + &["continuities"], + &["contiguous"], ], - range: 3..=4, + range: 3..=6, }; static WORD_CONTIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72629,8 +138274,14 @@ pub static WORD_CONTIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("ute"), dictgen::InsensitiveStr::Ascii("uted"), dictgen::InsensitiveStr::Ascii("utes"), + dictgen::InsensitiveStr::Ascii("utor"), + ], + values: &[ + &["contribute"], + &["contributed"], + &["contributes"], + &["contributor"], ], - values: &[&["contribute"], &["contributed"], &["contributes"]], range: 3..=4, }; @@ -72641,7 +138292,9 @@ static WORD_CONTIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -72649,7 +138302,9 @@ pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("ns"), ], values: &[ + &["contains"], &["contain"], + &["contained"], &["container"], &["containers"], &["containing"], @@ -72660,75 +138315,226 @@ pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d }; static WORD_CONTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONTE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONTE_CHILDREN), value: None, }; -pub static WORD_CONTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_CONTE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + None, + Some(&WORD_CONTEC_NODE), + None, + 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("ction"), - dictgen::InsensitiveStr::Ascii("ctual"), - dictgen::InsensitiveStr::Ascii("iners"), - dictgen::InsensitiveStr::Ascii("mpate"), - dictgen::InsensitiveStr::Ascii("mperary"), - dictgen::InsensitiveStr::Ascii("mplare"), - dictgen::InsensitiveStr::Ascii("mplat"), - dictgen::InsensitiveStr::Ascii("mple"), - dictgen::InsensitiveStr::Ascii("mpoary"), - dictgen::InsensitiveStr::Ascii("mporaneus"), - dictgen::InsensitiveStr::Ascii("mporany"), - dictgen::InsensitiveStr::Ascii("mporay"), - dictgen::InsensitiveStr::Ascii("mpory"), - dictgen::InsensitiveStr::Ascii("mt"), - dictgen::InsensitiveStr::Ascii("nants"), - dictgen::InsensitiveStr::Ascii("ncion"), - dictgen::InsensitiveStr::Ascii("ncious"), - dictgen::InsensitiveStr::Ascii("ndor"), - dictgen::InsensitiveStr::Ascii("ndors"), - dictgen::InsensitiveStr::Ascii("nental"), - dictgen::InsensitiveStr::Ascii("nents"), - dictgen::InsensitiveStr::Ascii("neurs"), - dictgen::InsensitiveStr::Ascii("ngency"), - dictgen::InsensitiveStr::Ascii("ngent"), - dictgen::InsensitiveStr::Ascii("nintal"), - dictgen::InsensitiveStr::Ascii("nplate"), - dictgen::InsensitiveStr::Ascii("nplating"), - dictgen::InsensitiveStr::Ascii("ns"), - dictgen::InsensitiveStr::Ascii("nse"), - dictgen::InsensitiveStr::Ascii("nsion"), - dictgen::InsensitiveStr::Ascii("nsious"), - dictgen::InsensitiveStr::Ascii("nst"), - dictgen::InsensitiveStr::Ascii("ntants"), - dictgen::InsensitiveStr::Ascii("ntas"), - dictgen::InsensitiveStr::Ascii("ntes"), - dictgen::InsensitiveStr::Ascii("ntino"), - dictgen::InsensitiveStr::Ascii("ntios"), - dictgen::InsensitiveStr::Ascii("ntos"), - dictgen::InsensitiveStr::Ascii("ntous"), - dictgen::InsensitiveStr::Ascii("ntuous"), - dictgen::InsensitiveStr::Ascii("ss"), - dictgen::InsensitiveStr::Ascii("stais"), - dictgen::InsensitiveStr::Ascii("stans"), - dictgen::InsensitiveStr::Ascii("stas"), - dictgen::InsensitiveStr::Ascii("stase"), - dictgen::InsensitiveStr::Ascii("staste"), - dictgen::InsensitiveStr::Ascii("stat"), - dictgen::InsensitiveStr::Ascii("stents"), - dictgen::InsensitiveStr::Ascii("stes"), - dictgen::InsensitiveStr::Ascii("stion"), - dictgen::InsensitiveStr::Ascii("stors"), - dictgen::InsensitiveStr::Ascii("xta"), - dictgen::InsensitiveStr::Ascii("xtes"), - dictgen::InsensitiveStr::Ascii("xtful"), - dictgen::InsensitiveStr::Ascii("xtl"), - dictgen::InsensitiveStr::Ascii("xtos"), - dictgen::InsensitiveStr::Ascii("xtuel"), - dictgen::InsensitiveStr::Ascii("xtura"), + 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: &[ - &["contention"], + &["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: None, +}; + +pub static WORD_CONTER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("mporaneous")], + values: &[&["contemporaneous"]], + range: 10..=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("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"], &["contemporary"], &["contemplate"], @@ -72740,128 +138546,183 @@ pub static WORD_CONTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["contemporary"], &["contemporary"], &["contempt"], - &["continents"], - &["contention"], - &["contentious"], - &["contender"], - &["contenders"], - &["continental"], - &["continents"], - &["contenders"], - &["contingency"], - &["contingent"], - &["continental"], - &["contemplate"], - &["contemplating"], - &["contents"], - &["contenders"], - &["contention"], - &["contentious"], - &["contents"], - &["contestants"], - &["contents"], - &["contents"], - &["contention"], - &["contentious"], - &["contents"], - &["contentious"], - &["contentious"], - &["contests"], - &["contests"], - &["contests"], - &["contests"], - &["contests"], - &["contestants"], - &["contestants"], - &["contestants"], - &["contests"], - &["contention"], - &["contests"], - &["contextual"], - &["contexts"], - &["contextual"], - &["contextual"], - &["contexts"], - &["contextual"], - &["contextual"], ], - range: 2..=9, + range: 1..=8, }; -static WORD_CONTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONTA_CHILDREN), +static WORD_CONTEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_CONTEI_CHILDREN), value: None, }; -pub static WORD_CONTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_CONTEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("cs"), - dictgen::InsensitiveStr::Ascii("ctes"), - dictgen::InsensitiveStr::Ascii("ction"), - dictgen::InsensitiveStr::Ascii("ctos"), - dictgen::InsensitiveStr::Ascii("geous"), - dictgen::InsensitiveStr::Ascii("gios"), - dictgen::InsensitiveStr::Ascii("giosa"), - dictgen::InsensitiveStr::Ascii("gioso"), - dictgen::InsensitiveStr::Ascii("giosum"), - dictgen::InsensitiveStr::Ascii("igous"), - dictgen::InsensitiveStr::Ascii("iminate"), - dictgen::InsensitiveStr::Ascii("ind"), - dictgen::InsensitiveStr::Ascii("inered"), - dictgen::InsensitiveStr::Ascii("ines"), - dictgen::InsensitiveStr::Ascii("ing"), - dictgen::InsensitiveStr::Ascii("inig"), - dictgen::InsensitiveStr::Ascii("inmemt"), - dictgen::InsensitiveStr::Ascii("inors"), - dictgen::InsensitiveStr::Ascii("inters"), - dictgen::InsensitiveStr::Ascii("inting"), - dictgen::InsensitiveStr::Ascii("ints"), - dictgen::InsensitiveStr::Ascii("ire"), - dictgen::InsensitiveStr::Ascii("is"), - dictgen::InsensitiveStr::Ascii("minacion"), - dictgen::InsensitiveStr::Ascii("minanted"), - dictgen::InsensitiveStr::Ascii("minatie"), - dictgen::InsensitiveStr::Ascii("minato"), - dictgen::InsensitiveStr::Ascii("minaton"), - dictgen::InsensitiveStr::Ascii("minen"), - dictgen::InsensitiveStr::Ascii("minent"), - dictgen::InsensitiveStr::Ascii("minents"), - dictgen::InsensitiveStr::Ascii("minted"), - dictgen::InsensitiveStr::Ascii("mporaries"), - dictgen::InsensitiveStr::Ascii("mporary"), - dictgen::InsensitiveStr::Ascii("ncting"), - dictgen::InsensitiveStr::Ascii("nimate"), - dictgen::InsensitiveStr::Ascii("nimated"), - dictgen::InsensitiveStr::Ascii("nimation"), - dictgen::InsensitiveStr::Ascii("niments"), - dictgen::InsensitiveStr::Ascii("nti"), - dictgen::InsensitiveStr::Ascii("nting"), - dictgen::InsensitiveStr::Ascii("st"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("ned"), + dictgen::InsensitiveStr::Ascii("ners"), + dictgen::InsensitiveStr::Ascii("ning"), + dictgen::InsensitiveStr::Ascii("ns"), ], values: &[ - &["contacts"], - &["contacts"], - &["contacting"], - &["contacts"], - &["contagious"], - &["contagious"], - &["contagious"], - &["contagious"], - &["contagious"], - &["contagious"], - &["contaminate"], - &["contained"], + &["contain"], &["contained"], + &["contenders"], + &["containing"], &["contains"], - &["containing"], - &["containing"], + ], + range: 1..=4, +}; + +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("enated"), + dictgen::InsensitiveStr::Ascii("ing"), + ], + values: &[&["concatenated"], &["contacting", "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("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"], + &["contaminated"], + &["contaminated"], + &["contamination"], &["containment"], - &["containers"], - &["containers"], + &["contained"], &["containing"], &["contains"], - &["containers"], &["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"], @@ -72873,16 +138734,139 @@ pub static WORD_CONTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["contaminated"], &["contemporaries"], &["contemporary"], - &["contracting"], + ], + 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("er"), + dictgen::InsensitiveStr::Ascii("gous"), + 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("nings"), + dictgen::InsensitiveStr::Ascii("nining"), + 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("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: &[ + &["container"], + &["contagious"], + &["contaminate"], &["contaminated"], - &["contaminated"], - &["contamination"], + &["contaminating"], + &["contain"], + &["contained"], + &["contain", "contained", "container", "contains"], + &["containers"], + &["contained"], + &["container"], + &["contains"], + &["containing"], + &["containing"], + &["containing"], + &["containing"], + &["containing"], + &["containing"], &["containment"], - &["contacting"], + &["contain"], + &["container"], + &["containers"], + &["contains"], + &["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: 2..=9, + range: 1..=7, }; static WORD_CONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -72891,7 +138875,7 @@ static WORD_CONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_CONSA_NODE), None, Some(&WORD_CONSC_NODE), Some(&WORD_CONSD_NODE), @@ -72908,7 +138892,7 @@ static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_CONSO_NODE), Some(&WORD_CONSP_NODE), Some(&WORD_CONSQ_NODE), - None, + Some(&WORD_CONSR_NODE), None, Some(&WORD_CONST_NODE), Some(&WORD_CONSU_NODE), @@ -72926,8 +138910,10 @@ static WORD_CONSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -72941,6 +138927,7 @@ pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ltent"), dictgen::InsensitiveStr::Ascii("mate"), dictgen::InsensitiveStr::Ascii("mated"), + dictgen::InsensitiveStr::Ascii("mating"), dictgen::InsensitiveStr::Ascii("mation"), dictgen::InsensitiveStr::Ascii("mbale"), dictgen::InsensitiveStr::Ascii("mbales"), @@ -72952,12 +138939,16 @@ pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("mires"), dictgen::InsensitiveStr::Ascii("mirse"), dictgen::InsensitiveStr::Ascii("miste"), + dictgen::InsensitiveStr::Ascii("mmed"), dictgen::InsensitiveStr::Ascii("mpion"), dictgen::InsensitiveStr::Ascii("ms"), + dictgen::InsensitiveStr::Ascii("mtion"), ], values: &[ + &["consider"], &["consulting"], &["counselling"], + &["consumer"], &["consultant"], &["consolation"], &["consultation"], @@ -72971,6 +138962,7 @@ pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["consultant"], &["consummate"], &["consummated"], + &["consummating"], &["consumption"], &["consumables"], &["consumables"], @@ -72982,8 +138974,10 @@ pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["consumerism"], &["consumerism"], &["consumes"], + &["consumed"], &["consumption"], &["consumes"], + &["consumption"], ], range: 2..=7, }; @@ -72996,7 +138990,7 @@ static WORD_CONST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_CONSTA_NODE), None, - None, + Some(&WORD_CONSTC_NODE), None, Some(&WORD_CONSTE_NODE), None, @@ -73005,7 +138999,7 @@ static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st Some(&WORD_CONSTI_NODE), None, None, - None, + Some(&WORD_CONSTL_NODE), None, Some(&WORD_CONSTN_NODE), None, @@ -73029,18 +139023,38 @@ static WORD_CONSTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("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"], + &["constructor"], + &["constructors"], + &["constructs"], + &["construct"], &["constructed"], &["construction"], + &["constructor"], &["construed"], ], - range: 3..=6, + range: 2..=6, }; static WORD_CONSTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73049,100 +139063,299 @@ static WORD_CONSTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_CONSTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ruction")], - values: &[&["construction"]], - range: 7..=7, + 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::Flat(&WORD_CONSTR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONSTR_CHILDREN), value: None, }; -pub static WORD_CONSTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[ - dictgen::InsensitiveStr::Ascii("acting"), - dictgen::InsensitiveStr::Ascii("action"), - dictgen::InsensitiveStr::Ascii("acts"), - dictgen::InsensitiveStr::Ascii("ainsts"), - dictgen::InsensitiveStr::Ascii("ait"), - dictgen::InsensitiveStr::Ascii("aits"), - dictgen::InsensitiveStr::Ascii("ansi"), - dictgen::InsensitiveStr::Ascii("ants"), - dictgen::InsensitiveStr::Ascii("at"), - dictgen::InsensitiveStr::Ascii("ating"), - dictgen::InsensitiveStr::Ascii("iants"), - dictgen::InsensitiveStr::Ascii("uccion"), - dictgen::InsensitiveStr::Ascii("uced"), - dictgen::InsensitiveStr::Ascii("ucing"), - dictgen::InsensitiveStr::Ascii("ucion"), - dictgen::InsensitiveStr::Ascii("uciton"), - dictgen::InsensitiveStr::Ascii("ucive"), - dictgen::InsensitiveStr::Ascii("ucs"), - dictgen::InsensitiveStr::Ascii("ucteds"), - dictgen::InsensitiveStr::Ascii("ucticon"), - dictgen::InsensitiveStr::Ascii("uctie"), - dictgen::InsensitiveStr::Ascii("uctief"), - dictgen::InsensitiveStr::Ascii("ucties"), - dictgen::InsensitiveStr::Ascii("uctieve"), - dictgen::InsensitiveStr::Ascii("uctifs"), - dictgen::InsensitiveStr::Ascii("uctiin"), - dictgen::InsensitiveStr::Ascii("uctiong"), - dictgen::InsensitiveStr::Ascii("uctivo"), - dictgen::InsensitiveStr::Ascii("ucto"), - dictgen::InsensitiveStr::Ascii("uctos"), - dictgen::InsensitiveStr::Ascii("uctur"), - dictgen::InsensitiveStr::Ascii("uctus"), - dictgen::InsensitiveStr::Ascii("ude"), - dictgen::InsensitiveStr::Ascii("uint"), - dictgen::InsensitiveStr::Ascii("uits"), - dictgen::InsensitiveStr::Ascii("ust"), - dictgen::InsensitiveStr::Ascii("ut"), - dictgen::InsensitiveStr::Ascii("uted"), - ], - values: &[ - &["constructing"], - &["construction"], - &["constructs"], - &["constraints"], - &["constraints"], - &["constraints"], - &["constraints"], - &["constraints"], - &["constraint"], - &["constraint"], - &["constraints"], - &["construction"], - &["constructed"], - &["constructing"], - &["construction"], - &["construction"], - &["constructive"], - &["constructs"], - &["constructs"], - &["construction"], - &["constructive"], - &["constructive"], - &["constructs"], - &["constructive"], - &["constructs"], - &["constructing"], - &["constructing"], - &["construction"], - &["construction"], - &["constructs"], - &["constructor"], - &["constructs"], - &["construed"], - &["constraint"], - &["constructs"], - &["constructs"], - &["constructs"], - &["constructed"], - ], - range: 2..=7, +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("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("t"), + dictgen::InsensitiveStr::Ascii("tced"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("ters"), + 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"], + &["constructs"], + &["constructed"], + &["construct"], + &["constructed"], + &["constructing"], + &["constructor"], + &["constructors"], + &["constructs"], + &["constructed"], + &["constructor"], + &["constructor"], + &["constructs"], + &["construed"], + &["constraint"], + &["constructs"], + &["constructor"], + &["constructor"], + &["constructors"], + &["constructs"], + &["constructs", "construct"], + &["constructed"], + &["constructed"], + &["constructor"], + &["constructors"], + &["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("llers")], + values: &[&["controllers"]], + range: 5..=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("ants")], + values: &[&["constraints"]], + range: 4..=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("ctor"), + dictgen::InsensitiveStr::Ascii("ctors"), + dictgen::InsensitiveStr::Ascii("cts"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("insts"), + dictgen::InsensitiveStr::Ascii("intes"), + 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"], + &["constructor"], + &["constructors"], + &["constructs"], + &["constraining", "constraint"], + &["constraints"], + &["constraints"], + &["constraints", "constraint"], + &["constraints"], + &["constrains"], + &["constraints"], + &["constraint"], + &["constraints"], + &["contrast"], + &["contrasts"], + &["constraint"], + &["constraint"], + &["constraints"], + &["constructs"], + ], + range: 1..=5, + }; + static WORD_CONSTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CONSTN_CHILDREN), value: None, @@ -73154,6 +139367,17 @@ pub static WORD_CONSTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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, @@ -73162,7 +139386,11 @@ static WORD_CONSTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -73197,7 +139425,11 @@ pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d ], values: &[ &["constellation"], + &["consisting"], &["continually"], + &["consistency"], + &["consists"], + &["consistently"], &["constitution"], &["constitutional"], &["constituent"], @@ -73207,7 +139439,7 @@ pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["constitution"], &["constitutional"], &["constitute"], - &["constitutes"], + &["constitutes", "constitute"], &["constitute"], &["constitute"], &["constitute"], @@ -73230,7 +139462,7 @@ pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["constitute"], &["constituents"], ], - range: 3..=9, + range: 2..=9, }; static WORD_CONSTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73239,8 +139471,22 @@ static WORD_CONSTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_CONSTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ntly")], - values: &[&["constantly"]], + 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, }; @@ -73251,13 +139497,19 @@ static WORD_CONSTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("ints"), dictgen::InsensitiveStr::Ascii("llation"), + dictgen::InsensitiveStr::Ascii("llations"), 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("rints"), dictgen::InsensitiveStr::Ascii("rnation"), @@ -73265,15 +139517,23 @@ pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("st"), dictgen::InsensitiveStr::Ascii("tn"), dictgen::InsensitiveStr::Ascii("tnly"), + dictgen::InsensitiveStr::Ascii("tnt"), + dictgen::InsensitiveStr::Ascii("tnts"), ], values: &[ + &["constrain", "contain"], + &["constrained", "contained"], + &["constraining", "containing"], + &["constrains", "contains"], &["constraints"], &["constellation"], + &["constellations"], &["constantly"], &["constants"], &["constants"], &["constants"], &["constants"], + &["constants"], &["constantly"], &["constraint"], &["consternation"], @@ -73281,8 +139541,41 @@ pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["constants"], &["constant"], &["constantly"], + &["constant"], + &["constants"], ], - range: 2..=7, + range: 2..=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 { @@ -73291,9 +139584,21 @@ static WORD_CONSQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_CONSQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("euences")], - values: &[&["consequence"]], - range: 7..=7, + 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 { @@ -73338,6 +139643,7 @@ static WORD_CONSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -73355,6 +139661,7 @@ pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("rcium"), ], values: &[ + &["console"], &["consolation"], &["consolation"], &["consolidate"], @@ -73371,7 +139678,7 @@ pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["consonants"], &["consortium"], ], - range: 4..=7, + range: 1..=7, }; static WORD_CONSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73390,74 +139697,300 @@ pub static WORD_CONSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_CONSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONSI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONSI_CHILDREN), value: None, }; -pub static WORD_CONSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("cence"), - dictgen::InsensitiveStr::Ascii("ciousness"), - dictgen::InsensitiveStr::Ascii("cous"), - dictgen::InsensitiveStr::Ascii("cousness"), - dictgen::InsensitiveStr::Ascii("derabe"), - dictgen::InsensitiveStr::Ascii("derabely"), - dictgen::InsensitiveStr::Ascii("derabile"), - dictgen::InsensitiveStr::Ascii("derablely"), - dictgen::InsensitiveStr::Ascii("derabley"), - dictgen::InsensitiveStr::Ascii("derablly"), - dictgen::InsensitiveStr::Ascii("deracion"), - dictgen::InsensitiveStr::Ascii("derais"), - dictgen::InsensitiveStr::Ascii("derant"), - dictgen::InsensitiveStr::Ascii("derarle"), - dictgen::InsensitiveStr::Ascii("derarte"), - dictgen::InsensitiveStr::Ascii("deras"), - dictgen::InsensitiveStr::Ascii("deraste"), - dictgen::InsensitiveStr::Ascii("deratie"), - dictgen::InsensitiveStr::Ascii("deratin"), - dictgen::InsensitiveStr::Ascii("derato"), - dictgen::InsensitiveStr::Ascii("deratoin"), - dictgen::InsensitiveStr::Ascii("derble"), - dictgen::InsensitiveStr::Ascii("derbly"), - dictgen::InsensitiveStr::Ascii("derd"), - dictgen::InsensitiveStr::Ascii("dereis"), - dictgen::InsensitiveStr::Ascii("deret"), - dictgen::InsensitiveStr::Ascii("deribly"), - dictgen::InsensitiveStr::Ascii("derstion"), - dictgen::InsensitiveStr::Ascii("derstions"), - dictgen::InsensitiveStr::Ascii("dert"), - dictgen::InsensitiveStr::Ascii("dertaion"), - dictgen::InsensitiveStr::Ascii("lation"), - dictgen::InsensitiveStr::Ascii("lidate"), - dictgen::InsensitiveStr::Ascii("lidated"), - dictgen::InsensitiveStr::Ascii("ous"), - dictgen::InsensitiveStr::Ascii("pracies"), - dictgen::InsensitiveStr::Ascii("pracy"), - dictgen::InsensitiveStr::Ascii("quently"), - dictgen::InsensitiveStr::Ascii("sent"), - dictgen::InsensitiveStr::Ascii("stance"), - dictgen::InsensitiveStr::Ascii("stant"), - dictgen::InsensitiveStr::Ascii("stantly"), - dictgen::InsensitiveStr::Ascii("stencey"), - dictgen::InsensitiveStr::Ascii("stenly"), - dictgen::InsensitiveStr::Ascii("stens"), - dictgen::InsensitiveStr::Ascii("stensy"), - dictgen::InsensitiveStr::Ascii("stentcy"), - dictgen::InsensitiveStr::Ascii("stenty"), - dictgen::InsensitiveStr::Ascii("steny"), - dictgen::InsensitiveStr::Ascii("stes"), - dictgen::InsensitiveStr::Ascii("tency"), - dictgen::InsensitiveStr::Ascii("tuencies"), - dictgen::InsensitiveStr::Ascii("tuted"), - dictgen::InsensitiveStr::Ascii("tutents"), - dictgen::InsensitiveStr::Ascii("tution"), - dictgen::InsensitiveStr::Ascii("tutional"), + 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: &[ - &["conscience"], - &["consciousness"], - &["conscious"], - &["consciousness"], + &["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"], + &["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("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("erstion"), + dictgen::InsensitiveStr::Ascii("erstions"), + dictgen::InsensitiveStr::Ascii("ert"), + dictgen::InsensitiveStr::Ascii("ertaion"), + dictgen::InsensitiveStr::Ascii("red"), + ], + values: &[ + &["consider"], + &["consideration"], + &["considered"], + &["considering"], &["considerate"], &["considerable"], &["considerable"], @@ -73478,40 +140011,40 @@ pub static WORD_CONSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["considerable"], &["considerably"], &["considered"], + &["consider", "considered"], &["considers"], + &["considered"], + &["considered", "considers"], &["considerate"], &["considerably"], &["considerations"], &["considerations"], - &["considerate"], + &["considerate", "considered", "consider"], &["considerations"], - &["consolation"], - &["consolidate"], - &["consolidated"], - &["conscious"], - &["conspiracies"], - &["conspiracy"], - &["consequently"], - &["consistent"], - &["consistency"], - &["consistent"], - &["consistently"], - &["consistency"], - &["consistently"], - &["consists"], - &["consistency"], - &["consistently"], - &["consistently"], - &["consistency"], - &["consists"], - &["consistency"], - &["constituencies"], - &["constituted"], - &["constituents"], - &["constitution"], - &["constitutional"], + &["considered"], ], - range: 3..=9, + range: 3..=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("ence"), + dictgen::InsensitiveStr::Ascii("iousness"), + dictgen::InsensitiveStr::Ascii("ous"), + dictgen::InsensitiveStr::Ascii("ousness"), + ], + values: &[ + &["conscience"], + &["consciousness"], + &["conscious"], + &["consciousness"], + ], + range: 3..=8, }; static WORD_CONSF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73526,114 +140059,102 @@ pub static WORD_CONSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di }; static WORD_CONSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONSE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONSE_CHILDREN), value: None, }; -pub static WORD_CONSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("ctuive"), - dictgen::InsensitiveStr::Ascii("ctutive"), - dictgen::InsensitiveStr::Ascii("cuence"), - dictgen::InsensitiveStr::Ascii("cuences"), - dictgen::InsensitiveStr::Ascii("cuentes"), - dictgen::InsensitiveStr::Ascii("cuently"), - dictgen::InsensitiveStr::Ascii("guence"), - dictgen::InsensitiveStr::Ascii("lation"), - dictgen::InsensitiveStr::Ascii("nding"), - dictgen::InsensitiveStr::Ascii("nquently"), - dictgen::InsensitiveStr::Ascii("nsuarlo"), - dictgen::InsensitiveStr::Ascii("nsuel"), - dictgen::InsensitiveStr::Ascii("nsul"), - 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("nusal"), - dictgen::InsensitiveStr::Ascii("pt"), - dictgen::InsensitiveStr::Ascii("qeunces"), - dictgen::InsensitiveStr::Ascii("quece"), - dictgen::InsensitiveStr::Ascii("quencies"), - dictgen::InsensitiveStr::Ascii("quenes"), - dictgen::InsensitiveStr::Ascii("quense"), - dictgen::InsensitiveStr::Ascii("quenses"), - dictgen::InsensitiveStr::Ascii("quental"), - dictgen::InsensitiveStr::Ascii("quente"), - dictgen::InsensitiveStr::Ascii("quentely"), - dictgen::InsensitiveStr::Ascii("quentually"), - dictgen::InsensitiveStr::Ascii("quenty"), - dictgen::InsensitiveStr::Ascii("queseces"), - dictgen::InsensitiveStr::Ascii("qunce"), - dictgen::InsensitiveStr::Ascii("quneces"), - dictgen::InsensitiveStr::Ascii("qutive"), - dictgen::InsensitiveStr::Ascii("rn"), - dictgen::InsensitiveStr::Ascii("rned"), - dictgen::InsensitiveStr::Ascii("rvacion"), - dictgen::InsensitiveStr::Ascii("rvanti"), - dictgen::InsensitiveStr::Ascii("rvare"), - dictgen::InsensitiveStr::Ascii("rvatie"), - dictgen::InsensitiveStr::Ascii("rvaties"), - dictgen::InsensitiveStr::Ascii("rvatisim"), - dictgen::InsensitiveStr::Ascii("rvativo"), - dictgen::InsensitiveStr::Ascii("rvativs"), - dictgen::InsensitiveStr::Ascii("rvativsm"), - dictgen::InsensitiveStr::Ascii("rvato"), - dictgen::InsensitiveStr::Ascii("rvaton"), - dictgen::InsensitiveStr::Ascii("rvice"), - dictgen::InsensitiveStr::Ascii("rvies"), - dictgen::InsensitiveStr::Ascii("rvitave"), - dictgen::InsensitiveStr::Ascii("rvite"), - dictgen::InsensitiveStr::Ascii("rvitism"), - dictgen::InsensitiveStr::Ascii("rvitive"), - dictgen::InsensitiveStr::Ascii("rvitives"), + 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: &[ - &["consecutive"], - &["consecutive"], - &["consequence"], - &["consequences"], - &["consequences"], - &["consequently"], - &["consequence"], - &["consolation"], - &["consenting"], - &["consequently"], - &["consensual"], - &["consensual"], - &["consensual"], - &["concentrate"], - &["concentrated"], - &["concentrates"], - &["concentrating"], - &["concentration"], - &["concentrations"], - &["consensual"], - &["concept"], - &["consequence"], - &["consequence"], - &["consequence"], - &["consequence"], - &["consequences"], - &["consequences"], - &["consequently"], - &["consequence"], - &["consequently"], - &["consequently"], - &["consequently"], - &["consequences"], - &["consequence"], - &["consequence"], - &["consecutive"], &["concern"], &["concerned"], + &["concerning"], &["conservation"], &["conservation"], &["conserve"], &["conservatives"], &["conservatives"], &["conservatism"], + &["conservatively"], &["conservation"], &["conservatism"], &["conservatism"], @@ -73647,7 +140168,188 @@ pub static WORD_CONSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["conservative"], &["conservatives"], ], - range: 2..=10, + 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("suarlo"), + dictgen::InsensitiveStr::Ascii("suel"), + dictgen::InsensitiveStr::Ascii("sul"), + 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"], + &["consensual"], + &["consensual"], + &["consensual"], + &["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("uence"), + dictgen::InsensitiveStr::Ascii("uences"), + dictgen::InsensitiveStr::Ascii("uentes"), + dictgen::InsensitiveStr::Ascii("uently"), + dictgen::InsensitiveStr::Ascii("uitively"), + ], + values: &[ + &["consecutive"], + &["consecutively"], + &["consecutive"], + &["consecutive"], + &["consequence"], + &["consequences"], + &["consequences"], + &["consequently"], + &["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 { @@ -73661,12 +140363,14 @@ pub static WORD_CONSD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, }; @@ -73679,6 +140383,7 @@ static WORD_CONSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -73687,6 +140392,7 @@ pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di ], values: &[ &["consent"], + &["conscientious"], &["conscience"], &["consciously"], &["consciousness"], @@ -73696,6 +140402,56 @@ pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("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"), + ], + values: &[ + &["concrete"], + &["control"], + &["controller"], + &["control"], + &["corrupt"], + &["corruptible"], + &["corrupted"], + &["corruptible"], + &["corruption"], + &["corruptions"], + &["corrupts"], + &["contrib"], + &["contribs"], + ], + range: 2..=8, +}; + static WORD_CONQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CONQ_CHILDREN), value: None, @@ -73738,10 +140494,16 @@ static WORD_CONP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -73751,10 +140513,16 @@ pub static WORD_CONP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("siracy"), ], values: &[ + &["compares"], &["compassionate"], &["compensating"], &["compensation"], &["competitions"], + &["complete"], + &["completed"], + &["completes"], + &["completing"], + &["completion"], &["complications"], &["complimentary"], &["complimented"], @@ -73763,7 +140531,7 @@ pub static WORD_CONP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["compromising"], &["conspiracy"], ], - range: 6..=9, + range: 4..=9, }; static WORD_CONO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73775,79 +140543,300 @@ pub static WORD_CONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("lization"), dictgen::InsensitiveStr::Ascii("ntation"), + dictgen::InsensitiveStr::Ascii("suer"), + dictgen::InsensitiveStr::Ascii("tation"), dictgen::InsensitiveStr::Ascii("tations"), ], - values: &[&["colonization"], &["connotation"], &["connotations"]], - range: 7..=8, + values: &[ + &["colonization"], + &["connotation"], + &["connoisseur"], + &["connotation"], + &["connotations"], + ], + range: 4..=8, }; static WORD_CONN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONN_CHILDREN), value: None, }; -pub static WORD_CONN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("atation"), - dictgen::InsensitiveStr::Ascii("atations"), - dictgen::InsensitiveStr::Ascii("cetion"), - dictgen::InsensitiveStr::Ascii("ecitcut"), - dictgen::InsensitiveStr::Ascii("eciton"), - dictgen::InsensitiveStr::Ascii("ecs"), - dictgen::InsensitiveStr::Ascii("ectes"), - dictgen::InsensitiveStr::Ascii("ecticon"), - dictgen::InsensitiveStr::Ascii("ecticuit"), - dictgen::InsensitiveStr::Ascii("ecticunts"), - dictgen::InsensitiveStr::Ascii("ecties"), - dictgen::InsensitiveStr::Ascii("ectins"), - dictgen::InsensitiveStr::Ascii("ectiong"), - dictgen::InsensitiveStr::Ascii("ectit"), - dictgen::InsensitiveStr::Ascii("ectivety"), - dictgen::InsensitiveStr::Ascii("ectivitiy"), - dictgen::InsensitiveStr::Ascii("ectivty"), - dictgen::InsensitiveStr::Ascii("ectivy"), - dictgen::InsensitiveStr::Ascii("ectos"), - dictgen::InsensitiveStr::Ascii("ectpro"), - dictgen::InsensitiveStr::Ascii("etation"), - dictgen::InsensitiveStr::Ascii("etations"), - dictgen::InsensitiveStr::Ascii("eticut"), - dictgen::InsensitiveStr::Ascii("itations"), - dictgen::InsensitiveStr::Ascii("onation"), - dictgen::InsensitiveStr::Ascii("onations"), - dictgen::InsensitiveStr::Ascii("otacion"), - dictgen::InsensitiveStr::Ascii("otaion"), + 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("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("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("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("ticut"), + dictgen::InsensitiveStr::Ascii("tion"), + dictgen::InsensitiveStr::Ascii("tor"), + ], + values: &[ + &["connected"], + &["connection"], &["connections"], &["connecticut"], &["connection"], + &["connections"], + &["connector"], + &["connector"], &["connects"], + &["connectstatus"], + &["connected"], + &["connected"], &["connects"], + &["connected"], + &["connectivity"], &["connection"], &["connecticut"], &["connecticut"], &["connects"], + &["connection"], + &["connections"], &["connects"], + &["connection"], + &["connections"], + &["connection"], + &["connections"], &["connecting"], &["connecticut"], &["connectivity"], &["connectivity"], &["connectivity"], &["connectivity"], + &["connect"], + &["connection", "connector"], &["connectors"], &["connector"], + &["connected"], + &["connection"], + &["connection"], + &["connection"], + &["connectors"], &["connotation"], &["connotations"], + &["connected"], + &["connection"], &["connecticut"], - &["connotations"], - &["connotation"], - &["connotations"], - &["connotation"], - &["connotation"], + &["connection"], + &["connector"], ], - range: 3..=9, + 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 { @@ -73859,16 +140848,22 @@ pub static WORD_CONL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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: 4..=7, + range: 1..=7, }; static WORD_CONJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73880,18 +140875,26 @@ pub static WORD_CONJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], - &["conjunction"], + &["conjunctions"], ], range: 6..=7, }; @@ -73907,9 +140910,25 @@ pub static WORD_CONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("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("sderation"), + dictgen::InsensitiveStr::Ascii("tinue"), dictgen::InsensitiveStr::Ascii("ved"), ], values: &[ @@ -73917,12 +140936,28 @@ pub static WORD_CONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["coincidence"], &["coincidental"], &["coincidentally"], + &["consider"], + &["configurations", "configuration"], &["configurations"], - &["configurations"], + &["configuration"], + &["config"], + &["coincide"], + &["coincidence"], + &["coincident"], + &["coincides"], + &["coinciding"], + &["convenient"], + &["coinstallable"], + &["continuation"], + &["continue"], + &["continues"], + &["continuity"], + &["continuous"], &["considerations"], + &["continue"], &["connived"], ], - range: 3..=10, + range: 1..=10, }; static WORD_CONG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -73934,6 +140969,11 @@ pub static WORD_CONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("igure"), dictgen::InsensitiveStr::Ascii("itive"), dictgen::InsensitiveStr::Ascii("laturation"), dictgen::InsensitiveStr::Ascii("laturations"), @@ -73963,6 +141003,11 @@ pub static WORD_CONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["congregation"], &["congregation"], + &["configurable"], + &["configuration"], + &["configure"], + &["configured"], + &["configure"], &["cognitive"], &["congratulations"], &["congratulations"], @@ -74003,8 +141048,8 @@ static WORD_CONF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_CONFE_NODE), - None, - None, + Some(&WORD_CONFF_NODE), + Some(&WORD_CONFG_NODE), None, Some(&WORD_CONFI_NODE), None, @@ -74033,12 +141078,118 @@ static WORD_CONFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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: &[&["configurations"], &["confession"], &["confessions"]], - range: 5..=9, + 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"], + &["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 { @@ -74050,7 +141201,9 @@ pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -74064,7 +141217,9 @@ pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di values: &[ &["confrontation"], &["confrontational"], + &["confirm"], &["confirmation"], + &["confirmations"], &["confirmed"], &["confirming"], &["confirms"], @@ -74075,7 +141230,7 @@ pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["confrontation"], &["confrontation"], ], - range: 3..=10, + range: 2..=10, }; static WORD_CONFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -74084,9 +141239,13 @@ static WORD_CONFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_CONFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rtable")], - values: &[&["comfortable"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("guration"), + dictgen::InsensitiveStr::Ascii("rt"), + dictgen::InsensitiveStr::Ascii("rtable"), + ], + values: &[&["configuration"], &["comfort"], &["comfortable"]], + range: 2..=8, }; static WORD_CONFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -74102,7 +141261,10 @@ pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), ], @@ -74113,67 +141275,339 @@ pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["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::Flat(&WORD_CONFI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONFI_CHILDREN), value: None, }; -pub static WORD_CONFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("dance"), - dictgen::InsensitiveStr::Ascii("dantly"), - dictgen::InsensitiveStr::Ascii("dencial"), - dictgen::InsensitiveStr::Ascii("denciality"), - dictgen::InsensitiveStr::Ascii("denly"), - dictgen::InsensitiveStr::Ascii("dense"), - dictgen::InsensitiveStr::Ascii("dentail"), - dictgen::InsensitiveStr::Ascii("dentally"), - dictgen::InsensitiveStr::Ascii("dentaly"), - dictgen::InsensitiveStr::Ascii("dentely"), - dictgen::InsensitiveStr::Ascii("dentiel"), - dictgen::InsensitiveStr::Ascii("dentuality"), - dictgen::InsensitiveStr::Ascii("denty"), - dictgen::InsensitiveStr::Ascii("deny"), - dictgen::InsensitiveStr::Ascii("ds"), - dictgen::InsensitiveStr::Ascii("gruation"), - dictgen::InsensitiveStr::Ascii("guartion"), - dictgen::InsensitiveStr::Ascii("guartions"), - dictgen::InsensitiveStr::Ascii("gue"), - dictgen::InsensitiveStr::Ascii("guracion"), - dictgen::InsensitiveStr::Ascii("guraiton"), - dictgen::InsensitiveStr::Ascii("gurare"), - dictgen::InsensitiveStr::Ascii("gurate"), - dictgen::InsensitiveStr::Ascii("guratin"), - dictgen::InsensitiveStr::Ascii("gurato"), - dictgen::InsensitiveStr::Ascii("guratoin"), - dictgen::InsensitiveStr::Ascii("guraton"), - dictgen::InsensitiveStr::Ascii("gureable"), - dictgen::InsensitiveStr::Ascii("lct"), - dictgen::InsensitiveStr::Ascii("lcting"), - dictgen::InsensitiveStr::Ascii("lcts"), - dictgen::InsensitiveStr::Ascii("mred"), - dictgen::InsensitiveStr::Ascii("ns"), - dictgen::InsensitiveStr::Ascii("rmacion"), - dictgen::InsensitiveStr::Ascii("rmas"), - dictgen::InsensitiveStr::Ascii("rmd"), - dictgen::InsensitiveStr::Ascii("se"), - dictgen::InsensitiveStr::Ascii("sgated"), + dictgen::InsensitiveStr::Ascii("g"), + dictgen::InsensitiveStr::Ascii("gure"), + ], + values: &[&["config"], &["configure"]], + range: 1..=4, +}; + +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("s")], + values: &[&["confines"]], + range: 1..=1, +}; + +static WORD_CONFIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_CONFIM_CHILDREN), + value: None, +}; + +pub static WORD_CONFIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("red")], + values: &[&["confirmed"]], + range: 3..=3, +}; + +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::Flat(&WORD_CONFIG_CHILDREN), + value: None, +}; + +pub static WORD_CONFIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("aration"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("er"), + dictgen::InsensitiveStr::Ascii("iration"), + dictgen::InsensitiveStr::Ascii("ire"), + dictgen::InsensitiveStr::Ascii("iuration"), + dictgen::InsensitiveStr::Ascii("ration"), + dictgen::InsensitiveStr::Ascii("rations"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("ruated"), + dictgen::InsensitiveStr::Ascii("ruation"), + dictgen::InsensitiveStr::Ascii("ruations"), + dictgen::InsensitiveStr::Ascii("rued"), + dictgen::InsensitiveStr::Ascii("uaration"), + dictgen::InsensitiveStr::Ascii("uarble"), + dictgen::InsensitiveStr::Ascii("uare"), + dictgen::InsensitiveStr::Ascii("uared"), + dictgen::InsensitiveStr::Ascii("uarion"), + dictgen::InsensitiveStr::Ascii("uarions"), + dictgen::InsensitiveStr::Ascii("uartion"), + dictgen::InsensitiveStr::Ascii("uartions"), + dictgen::InsensitiveStr::Ascii("uation"), + dictgen::InsensitiveStr::Ascii("uations"), + dictgen::InsensitiveStr::Ascii("ue"), + dictgen::InsensitiveStr::Ascii("ued"), + dictgen::InsensitiveStr::Ascii("uerd"), + dictgen::InsensitiveStr::Ascii("ues"), + dictgen::InsensitiveStr::Ascii("uracion"), + dictgen::InsensitiveStr::Ascii("uraion"), + dictgen::InsensitiveStr::Ascii("uraiton"), + dictgen::InsensitiveStr::Ascii("urare"), + dictgen::InsensitiveStr::Ascii("urate"), + dictgen::InsensitiveStr::Ascii("uratiens"), + dictgen::InsensitiveStr::Ascii("uratin"), + dictgen::InsensitiveStr::Ascii("uratiom"), + dictgen::InsensitiveStr::Ascii("urationn"), + dictgen::InsensitiveStr::Ascii("uratioon"), + dictgen::InsensitiveStr::Ascii("urato"), + dictgen::InsensitiveStr::Ascii("uratoin"), + dictgen::InsensitiveStr::Ascii("uratoins"), + dictgen::InsensitiveStr::Ascii("uraton"), + dictgen::InsensitiveStr::Ascii("uratons"), + dictgen::InsensitiveStr::Ascii("uratrions"), + dictgen::InsensitiveStr::Ascii("uratuion"), + dictgen::InsensitiveStr::Ascii("ureable"), + dictgen::InsensitiveStr::Ascii("ureing"), + dictgen::InsensitiveStr::Ascii("uretion"), + dictgen::InsensitiveStr::Ascii("urres"), + dictgen::InsensitiveStr::Ascii("urring"), + dictgen::InsensitiveStr::Ascii("urses"), + dictgen::InsensitiveStr::Ascii("urtation"), + dictgen::InsensitiveStr::Ascii("urting"), + dictgen::InsensitiveStr::Ascii("urtion"), + dictgen::InsensitiveStr::Ascii("ury"), + dictgen::InsensitiveStr::Ascii("utation"), + dictgen::InsensitiveStr::Ascii("utations"), + dictgen::InsensitiveStr::Ascii("utration"), + ], + values: &[ + &["configuration"], + &["configured"], + &["configure"], + &["configuration"], + &["configure"], + &["configuration"], + &["configuration"], + &["configurations"], + &["configured"], + &["configured", "configuration"], + &["configurations", "configuration"], + &["configurations"], + &["configured"], + &["configuration"], + &["configurable"], + &["configure"], + &["configured"], + &["configuration"], + &["configurations"], + &["configuration"], + &["configurations"], + &["configuration"], + &["configurations"], + &["configure"], + &["configured"], + &["configured"], + &["configures"], + &["configuration"], + &["configuration"], + &["configuration"], + &["configure"], + &["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"], + &["configurable"], + &["configuration"], + &["configurations"], + &["configuration"], + ], + range: 2..=9, +}; + +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"], @@ -74182,31 +141616,59 @@ pub static WORD_CONFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["confidently"], &["confidently"], &["confides"], - &["configurations"], - &["configuration"], - &["configurations"], - &["configure"], - &["configuration"], - &["configuration"], - &["configure"], - &["configure"], - &["configurations"], - &["configuration"], - &["configurations"], - &["configuration"], - &["configurable"], - &["conflict"], - &["conflicting"], - &["conflicts"], - &["confirmed"], - &["confines"], - &["confirmation"], - &["confirms"], - &["confirmed"], - &["confines"], - &["confiscated"], ], - range: 2..=10, + 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 { @@ -74234,7 +141696,9 @@ pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -74243,6 +141707,7 @@ pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ssionis"), dictgen::InsensitiveStr::Ascii("sso"), dictgen::InsensitiveStr::Ascii("sssion"), + dictgen::InsensitiveStr::Ascii("ty"), ], values: &[ &["confederacy"], @@ -74263,7 +141728,9 @@ pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["confirmation"], &["confirming"], &["conferences"], + &["conferencing"], &["conservation"], + &["convert"], &["confiscated"], &["confess"], &["confess"], @@ -74272,184 +141739,654 @@ pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["confessions"], &["confession"], &["confessions"], + &["confetti"], ], - range: 3..=7, + range: 2..=8, }; static WORD_CONE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CONE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CONE_CHILDREN), value: None, }; -pub static WORD_CONE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("cntration"), - dictgen::InsensitiveStr::Ascii("cted"), - dictgen::InsensitiveStr::Ascii("ction"), - dictgen::InsensitiveStr::Ascii("ncting"), - dictgen::InsensitiveStr::Ascii("nction"), - dictgen::InsensitiveStr::Ascii("nctions"), - dictgen::InsensitiveStr::Ascii("nctivity"), - dictgen::InsensitiveStr::Ascii("nctor"), - dictgen::InsensitiveStr::Ascii("nctors"), - dictgen::InsensitiveStr::Ascii("nctration"), - dictgen::InsensitiveStr::Ascii("ncts"), - dictgen::InsensitiveStr::Ascii("scutive"), - dictgen::InsensitiveStr::Ascii("sencus"), + 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: &[ - &["concentrations"], &["connected"], - &["connection"], &["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"], - &["consecutive"], - &["consensus"], + &["convenience"], + &["convenient"], + &["convenience"], + &["convenient"], + &["content"], + &["contents"], ], - range: 4..=9, + range: 1..=9, }; -static WORD_COND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_COND_CHILDREN), +static WORD_CONEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_CONEE_CHILDREN), value: None, }; -pub static WORD_COND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_CONEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("amnation"), - dictgen::InsensitiveStr::Ascii("amned"), - dictgen::InsensitiveStr::Ascii("amning"), - dictgen::InsensitiveStr::Ascii("ascending"), - dictgen::InsensitiveStr::Ascii("eferacy"), - dictgen::InsensitiveStr::Ascii("emantion"), - dictgen::InsensitiveStr::Ascii("emend"), - dictgen::InsensitiveStr::Ascii("emmed"), - dictgen::InsensitiveStr::Ascii("emming"), - dictgen::InsensitiveStr::Ascii("emnd"), - dictgen::InsensitiveStr::Ascii("emnig"), - dictgen::InsensitiveStr::Ascii("encing"), - dictgen::InsensitiveStr::Ascii("enm"), - dictgen::InsensitiveStr::Ascii("enmation"), - dictgen::InsensitiveStr::Ascii("enmed"), - dictgen::InsensitiveStr::Ascii("enming"), - dictgen::InsensitiveStr::Ascii("ensend"), - dictgen::InsensitiveStr::Ascii("escencion"), - dictgen::InsensitiveStr::Ascii("escendion"), - dictgen::InsensitiveStr::Ascii("escening"), - dictgen::InsensitiveStr::Ascii("escenion"), - dictgen::InsensitiveStr::Ascii("escenscion"), - dictgen::InsensitiveStr::Ascii("escensing"), - dictgen::InsensitiveStr::Ascii("esend"), - dictgen::InsensitiveStr::Ascii("esned"), - dictgen::InsensitiveStr::Ascii("icional"), - dictgen::InsensitiveStr::Ascii("idtion"), - dictgen::InsensitiveStr::Ascii("idtions"), - dictgen::InsensitiveStr::Ascii("iscending"), - dictgen::InsensitiveStr::Ascii("itinal"), - dictgen::InsensitiveStr::Ascii("itiner"), - dictgen::InsensitiveStr::Ascii("itionar"), - dictgen::InsensitiveStr::Ascii("itiond"), - dictgen::InsensitiveStr::Ascii("itionel"), - dictgen::InsensitiveStr::Ascii("itiong"), - dictgen::InsensitiveStr::Ascii("itionnal"), - dictgen::InsensitiveStr::Ascii("itionned"), - dictgen::InsensitiveStr::Ascii("itionner"), - dictgen::InsensitiveStr::Ascii("itionning"), + 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), + None, + 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("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("iut"), - dictgen::InsensitiveStr::Ascii("men"), - dictgen::InsensitiveStr::Ascii("menation"), - dictgen::InsensitiveStr::Ascii("mened"), - dictgen::InsensitiveStr::Ascii("mening"), - dictgen::InsensitiveStr::Ascii("olances"), - dictgen::InsensitiveStr::Ascii("olencies"), - dictgen::InsensitiveStr::Ascii("olensces"), - dictgen::InsensitiveStr::Ascii("olenses"), - dictgen::InsensitiveStr::Ascii("olonces"), - dictgen::InsensitiveStr::Ascii("omes"), - dictgen::InsensitiveStr::Ascii("omnation"), - dictgen::InsensitiveStr::Ascii("omns"), - dictgen::InsensitiveStr::Ascii("radicted"), - dictgen::InsensitiveStr::Ascii("radicting"), - dictgen::InsensitiveStr::Ascii("radiction"), - dictgen::InsensitiveStr::Ascii("radictions"), - dictgen::InsensitiveStr::Ascii("radictory"), - dictgen::InsensitiveStr::Ascii("uctiong"), - dictgen::InsensitiveStr::Ascii("uict"), - dictgen::InsensitiveStr::Ascii("uiting"), - dictgen::InsensitiveStr::Ascii("ulences"), + dictgen::InsensitiveStr::Ascii("onally"), + dictgen::InsensitiveStr::Ascii("scending"), + 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"], + &["confident"], + &["confidential"], + &["conditional"], + &["condition"], + &["conditioning"], + &["conditions"], + &["configurable"], + &["configuration"], + &["configure"], + &["configured"], + &["config"], + &["configdialog"], + &["condition"], + &["conditionally"], + &["condescending"], + &["conditional"], + &["conditioner"], + &["conditionally"], + &["conditioner"], + &["conditioned"], + &["conditional"], + &["conditioning"], + &["condition"], + &["conditional"], + &["conditionally"], + &["conditioned"], + &["conditioner"], + &["conditioning"], + &["conditional"], + &["condition"], + &["conditional"], + &["conditions"], + &["conduit"], + ], + range: 1..=8, +}; + +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"], - &["confederacy"], - &["condemnation"], - &["condemned"], - &["condemned"], - &["condemning"], - &["condemned"], - &["condemning"], - &["condemning"], - &["condemn"], - &["condemnation"], - &["condemned"], - &["condemning"], - &["condensed"], - &["condescension"], - &["condescension"], - &["condescending"], - &["condescension"], - &["condescension"], - &["condescension"], - &["condensed"], - &["condensed"], - &["conditional"], - &["condition"], - &["conditions"], - &["condescending"], - &["conditional"], - &["conditioner"], - &["conditioner"], - &["conditioned"], - &["conditional"], - &["conditioning"], - &["conditional"], - &["conditioned"], - &["conditioner"], - &["conditioning"], - &["condition"], - &["conduit"], - &["condemn"], - &["condemnation"], - &["condemned"], - &["condemning"], - &["condolences"], - &["condolences"], - &["condolences"], - &["condolences"], - &["condolences"], - &["condoms"], - &["condemnation"], - &["condoms"], - &["contradicted"], - &["contradicting"], - &["contradiction"], - &["contradictions"], - &["contradictory"], - &["conducting"], - &["conduit"], - &["conducting"], - &["condolences"], ], - range: 3..=10, + range: 4..=8, }; static WORD_CONC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -74496,6 +142433,11 @@ pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("lsion"), dictgen::InsensitiveStr::Ascii("lsions"), dictgen::InsensitiveStr::Ascii("lsive"), + dictgen::InsensitiveStr::Ascii("rence"), + dictgen::InsensitiveStr::Ascii("rency"), + dictgen::InsensitiveStr::Ascii("rent"), + dictgen::InsensitiveStr::Ascii("rently"), + dictgen::InsensitiveStr::Ascii("rents"), dictgen::InsensitiveStr::Ascii("rment"), dictgen::InsensitiveStr::Ascii("rrant"), dictgen::InsensitiveStr::Ascii("rrect"), @@ -74508,6 +142450,11 @@ pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["conclusion"], &["conclusions"], &["conclusive"], + &["concurrence"], + &["concurrency"], + &["concurrent"], + &["concurrently"], + &["concurrents", "concurrence"], &["concurrent"], &["concurrent"], &["concurrent"], @@ -74628,6 +142575,7 @@ static WORD_CONCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -74638,6 +142586,7 @@ pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -74649,6 +142598,7 @@ pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di ], values: &[ &["concise"], + &["concisely"], &["consider"], &["considerable"], &["considerably"], @@ -74659,6 +142609,7 @@ pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["considers"], &["concise"], &["conceited"], + &["conceive"], &["conceived"], &["conscious"], &["consciously"], @@ -74759,8 +142710,11 @@ static WORD_CONCER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -74772,9 +142726,12 @@ pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("vatives"), ], values: &[ - &["concede"], + &["concede", "concerned"], + &["concerned"], + &["concerning"], &["concerning"], &["concert"], + &["concentrating"], &["conservation"], &["concession"], &["concerts"], @@ -74785,7 +142742,7 @@ pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["conservative"], &["conservatives"], ], - range: 2..=7, + range: 2..=8, }; static WORD_CONCEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -74838,9 +142795,15 @@ pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -74858,6 +142821,7 @@ pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("tratin"), dictgen::InsensitiveStr::Ascii("trato"), dictgen::InsensitiveStr::Ascii("tratons"), + dictgen::InsensitiveStr::Ascii("traze"), ], values: &[ &["concentrate"], @@ -74865,8 +142829,14 @@ pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["concede"], &["concentrations"], &["consensus"], + &["consensus"], &["concentrations"], &["concentrate"], + &["concentrated"], + &["concentrates"], + &["concentrating"], + &["concentration"], + &["concentric"], &["connecting"], &["concentrate"], &["concentration"], @@ -74884,6 +142854,7 @@ pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["concentration"], &["concentration"], &["concentrations"], + &["concentrate"], ], range: 2..=7, }; @@ -74940,9 +142911,12 @@ static WORD_CONCEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_CONCEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("d")], - values: &[&["concede"]], - range: 1..=1, + keys: &[ + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("dd"), + ], + values: &[&["concede"], &["conceded"]], + range: 1..=2, }; static WORD_CONCED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -74977,11 +142951,52 @@ static WORD_CONCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("tinated"), dictgen::InsensitiveStr::Ascii("tination"), + dictgen::InsensitiveStr::Ascii("tinations"), + dictgen::InsensitiveStr::Ascii("ting"), + dictgen::InsensitiveStr::Ascii("tonate"), + dictgen::InsensitiveStr::Ascii("tonated"), + dictgen::InsensitiveStr::Ascii("tonates"), + dictgen::InsensitiveStr::Ascii("tonating"), ], - values: &[&["contaminated"], &["contamination"]], - range: 7..=8, + values: &[ + &["concatenated"], + &["concatenated"], + &["concatenated"], + &["concatenation"], + &["concatenated"], + &["concatenation"], + &["concatenate"], + &["concatenated"], + &["concatenates"], + &["concatenating"], + &["concatenation"], + &["concatenations"], + &["concatenated"], + &["contaminated", "concatenated"], + &["contamination", "concatenation"], + &["concatenations"], + &["concatenating"], + &["concatenate"], + &["concatenated"], + &["concatenates"], + &["concatenating"], + ], + range: 4..=10, }; static WORD_CONB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -74990,9 +143005,13 @@ static WORD_CONB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_CONB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("inations")], - values: &[&["combinations"]], - range: 8..=8, + keys: &[ + dictgen::InsensitiveStr::Ascii("ination"), + dictgen::InsensitiveStr::Ascii("inations"), + dictgen::InsensitiveStr::Ascii("trols"), + ], + values: &[&["combination"], &["combinations"], &["controls"]], + range: 5..=8, }; static WORD_CONA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75002,18 +143021,52 @@ static WORD_CONA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[ - &["canonical"], + &["contain"], + &["contained"], &["container"], &["containers"], &["contains"], + &["containing"], + &["contains"], + &["contain"], + &["contained"], + &["container"], + &["canonical"], + &["contain"], + &["container"], + &["containers"], + &["contains"], + &["contain"], + &["contained"], + &["container"], + &["containers"], + &["containing"], + &["contains"], ], - range: 4..=6, + range: 2..=7, }; static WORD_COM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75024,7 +143077,7 @@ static WORD_COM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_COMA_NODE), Some(&WORD_COMB_NODE), - None, + Some(&WORD_COMC_NODE), Some(&WORD_COMD_NODE), Some(&WORD_COME_NODE), Some(&WORD_COMF_NODE), @@ -75033,23 +143086,60 @@ static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_COMI_NODE), None, None, - None, + Some(&WORD_COML_NODE), Some(&WORD_COMM_NODE), - None, - None, + 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), - None, - None, + 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("nity"), + dictgen::InsensitiveStr::Ascii("te"), + dictgen::InsensitiveStr::Ascii("ted"), + ], + values: &[ + &["communicate"], + &["communication"], + &["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, @@ -75057,6 +143147,10 @@ static WORD_COMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("ains"), dictgen::InsensitiveStr::Ascii("aminated"), dictgen::InsensitiveStr::Ascii("amination"), dictgen::InsensitiveStr::Ascii("emplating"), @@ -75064,6 +143158,10 @@ pub static WORD_COMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("pon"), ], values: &[ + &["contain"], + &["contained"], + &["container"], + &["contains"], &["contaminated"], &["contamination"], &["contemplating"], @@ -75082,9 +143180,28 @@ pub static WORD_COMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("umption"), ], - values: &[&["cosmetic"], &["cosmetics"]], - range: 4..=5, + values: &[ + &["cosmetic"], + &["cosmetics"], + &["constraint"], + &["consume"], + &["consumed"], + &["consumer"], + &["consumers"], + &["consumes"], + &["consuming"], + &["consumption"], + ], + range: 3..=7, }; static WORD_COMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75097,12 +143214,18 @@ pub static WORD_COMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("adets"), dictgen::InsensitiveStr::Ascii("adre"), dictgen::InsensitiveStr::Ascii("ads"), + dictgen::InsensitiveStr::Ascii("ess"), + dictgen::InsensitiveStr::Ascii("essed"), + dictgen::InsensitiveStr::Ascii("ession"), dictgen::InsensitiveStr::Ascii("pomising"), ], values: &[ &["comrades"], &["comrade"], &["comrades"], + &["compress"], + &["compressed"], + &["compression"], &["compromising"], ], range: 3..=8, @@ -75119,7 +143242,7 @@ static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_COMPE_NODE), - None, + Some(&WORD_COMPF_NODE), None, Some(&WORD_COMPH_NODE), Some(&WORD_COMPI_NODE), @@ -75129,7 +143252,7 @@ static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, Some(&WORD_COMPN_NODE), Some(&WORD_COMPO_NODE), - None, + Some(&WORD_COMPP_NODE), None, Some(&WORD_COMPR_NODE), Some(&WORD_COMPS_NODE), @@ -75149,6 +143272,8 @@ static WORD_COMPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("atation"), + dictgen::InsensitiveStr::Ascii("ation"), dictgen::InsensitiveStr::Ascii("lisve"), dictgen::InsensitiveStr::Ascii("losry"), dictgen::InsensitiveStr::Ascii("lsary"), @@ -75160,6 +143285,8 @@ pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -75167,15 +143294,21 @@ pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], &["compulsive"], &["compulsory"], &["compulsory"], @@ -75187,6 +143320,8 @@ pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["compulsion"], &["compulsory"], &["computation"], + &["compound"], + &["compounds"], &["compute"], &["compulsion"], &["compulsive"], @@ -75195,14 +143330,18 @@ pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["computation"], &["computational"], &["computation"], + &["computation"], &["computerized"], &["computation"], &["computational"], &["computation"], &["computation"], + &["computation"], &["compute"], + &["computation"], + &["computations"], ], - range: 3..=9, + range: 2..=9, }; static WORD_COMPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75212,22 +143351,28 @@ static WORD_COMPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[ - &["compatibility"], + &["compatible"], + &["compatibility", "computability"], &["completing"], &["completion"], &["computers"], + &["compatible"], &["compton"], + &["compute"], &["computers"], ], - range: 3..=7, + range: 2..=7, }; static WORD_COMPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75236,9 +143381,13 @@ static WORD_COMPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_COMPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ers")], - values: &[&["compress"]], - range: 3..=3, + 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 { @@ -75255,19 +143404,27 @@ pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("eses"), + dictgen::InsensitiveStr::Ascii("esing"), dictgen::InsensitiveStr::Ascii("esion"), 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("essio"), dictgen::InsensitiveStr::Ascii("esson"), @@ -75300,20 +143457,28 @@ pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["compromises"], &["compromising"], &["compress"], + &["compare", "compère"], + &["compressed"], &["comprehend"], &["comprehension"], &["compromised"], &["compromises"], &["compromising"], &["compression"], + &["compress", "compares"], &["compress"], &["compressed"], - &["compress"], + &["compressed"], + &["compressor"], + &["compress", "compresses"], + &["compressing"], &["compression"], &["compressor"], &["compressor"], &["compressor"], &["compressor"], + &["compressible"], + &["compressor"], &["compressor"], &["compression"], &["compressed"], @@ -75337,7 +143502,18 @@ pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["compromises"], &["compressor"], ], - range: 3..=8, + 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")], + values: &[&["compatible"]], + range: 6..=6, }; static WORD_COMPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75347,21 +143523,40 @@ static WORD_COMPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("nemt"), + dictgen::InsensitiveStr::Ascii("nemts"), dictgen::InsensitiveStr::Ascii("nenet"), 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("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"), @@ -75379,28 +143574,48 @@ pub static WORD_COMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], + &["components"], &["components"], &["components"], &["components"], &["compose"], + &["components", "component"], + &["components"], &["components"], &["compensate"], + &["composites"], + &["component"], + &["components"], &["compost"], &["comparable"], + &["composability"], &["compost"], + &["composability"], + &["composability"], &["composition"], &["compositions"], &["compositions"], &["compositions"], - &["compost"], + &["compost", "composite"], &["composite"], &["composite"], &["composite"], @@ -75413,6 +143628,7 @@ pub static WORD_COMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["compositions"], &["composition"], &["compost"], + &["compound"], ], range: 2..=10, }; @@ -75423,9 +143639,13 @@ static WORD_COMPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_COMPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ay")], - values: &[&["company"]], - range: 2..=2, + 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 { @@ -75446,14 +143666,14 @@ static WORD_COMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, None, None, + Some(&WORD_COMPLM_NODE), None, None, None, None, None, None, - None, - None, + Some(&WORD_COMPLT_NODE), Some(&WORD_COMPLU_NODE), None, None, @@ -75473,14 +143693,38 @@ pub static WORD_COMPLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("sions"), dictgen::InsensitiveStr::Ascii("sive"), dictgen::InsensitiveStr::Ascii("sory"), + dictgen::InsensitiveStr::Ascii("ter"), ], values: &[ &["compulsion"], &["compulsion"], &["compulsive"], &["compulsory"], + &["computer"], ], - range: 4..=5, + 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 { @@ -75490,10 +143734,13 @@ static WORD_COMPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -75516,9 +143763,15 @@ pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("ctaed"), dictgen::InsensitiveStr::Ascii("cted"), 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("les"), + dictgen::InsensitiveStr::Ascii("ling"), dictgen::InsensitiveStr::Ascii("mate"), dictgen::InsensitiveStr::Ascii("mation"), dictgen::InsensitiveStr::Ascii("menary"), @@ -75531,14 +143784,18 @@ pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("mentry"), dictgen::InsensitiveStr::Ascii("menty"), dictgen::InsensitiveStr::Ascii("nation"), + dictgen::InsensitiveStr::Ascii("ng"), dictgen::InsensitiveStr::Ascii("tation"), dictgen::InsensitiveStr::Ascii("tion"), ], values: &[ + &["compliance"], &["complicate"], &["complication"], &["compliance"], + &["compliance"], &["complains"], + &["compliance"], &["complaints"], &["compilation"], &["compilation"], @@ -75561,9 +143818,15 @@ pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["complicate"], &["complicated"], &["compliance"], + &["compliant"], &["compiler"], + &["compilers"], &["complication"], &["complications"], + &["compile"], + &["compiled"], + &["compiles"], + &["compiling"], &["complicate"], &["complication"], &["complimentary"], @@ -75576,6 +143839,7 @@ pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["complimentary"], &["complimentary"], &["complication"], + &["compiling"], &["complication"], &["completion"], ], @@ -75589,30 +143853,52 @@ static WORD_COMPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("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("taste"), 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("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("ts"), + dictgen::InsensitiveStr::Ascii("tte"), + dictgen::InsensitiveStr::Ascii("ttly"), dictgen::InsensitiveStr::Ascii("ty"), dictgen::InsensitiveStr::Ascii("xers"), dictgen::InsensitiveStr::Ascii("xety"), @@ -75622,30 +143908,52 @@ pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d dictgen::InsensitiveStr::Ascii("xy"), ], values: &[ + &["complete"], + &["completed"], + &["completes"], + &["completing"], &["compilation"], &["completely"], &["complicate"], &["complicated"], &["complications"], &["complete"], + &["complete"], + &["completed"], + &["completely"], + &["completeness"], + &["completely"], + &["complete"], + &["complement"], + &["completeness"], + &["compression"], + &["complete"], &["completes"], &["completes"], &["completing"], &["completion"], &["completely"], &["completely"], + &["completely"], &["completes"], &["complement"], &["completes"], &["complement"], &["completion"], &["completely"], + &["completely"], &["complexity"], &["complexity"], &["completion"], &["completion"], + &["completion"], + &["completion"], &["completely"], + &["completely"], + &["completeness"], &["completes"], + &["complete"], + &["completely"], &["completely"], &["complexes"], &["complexity"], @@ -75654,7 +143962,7 @@ pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["complexity"], &["complexity"], ], - range: 2..=7, + range: 1..=7, }; static WORD_COMPLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -75689,8 +143997,15 @@ pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], @@ -75704,8 +144019,15 @@ pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["complained"], &["complains"], &["complacent"], - &["complacent"], - &["completion"], + &["complained"], + &["complacent", "complete"], + &["completed"], + &["completes"], + &["completing"], + &["completion", "compilation"], + &["completely"], + &["completeness"], + &["completes"], ], range: 2..=6, }; @@ -75717,6 +144039,11 @@ static WORD_COMPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("lability"), dictgen::InsensitiveStr::Ascii("lacion"), dictgen::InsensitiveStr::Ascii("lance"), dictgen::InsensitiveStr::Ascii("lant"), @@ -75725,6 +144052,10 @@ pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("laton"), dictgen::InsensitiveStr::Ascii("lcated"), dictgen::InsensitiveStr::Ascii("lcations"), + dictgen::InsensitiveStr::Ascii("liant"), + dictgen::InsensitiveStr::Ascii("liation"), + dictgen::InsensitiveStr::Ascii("lier"), + dictgen::InsensitiveStr::Ascii("liers"), dictgen::InsensitiveStr::Ascii("lr"), dictgen::InsensitiveStr::Ascii("nation"), dictgen::InsensitiveStr::Ascii("nsate"), @@ -75737,8 +144068,14 @@ pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("tation"), dictgen::InsensitiveStr::Ascii("tent"), dictgen::InsensitiveStr::Ascii("tetion"), + dictgen::InsensitiveStr::Ascii("tible"), ], values: &[ + &["compliant"], + &["complicated"], + &["complications"], + &["compiled"], + &["compatibility"], &["compilation"], &["compliance"], &["compliant"], @@ -75747,6 +144084,10 @@ pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["compilation"], &["complicate"], &["complication"], + &["compliant"], + &["compilation"], + &["compiler"], + &["compilers"], &["compiler"], &["compilation"], &["compensate"], @@ -75759,6 +144100,7 @@ pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["computation"], &["competent"], &["competitions"], + &["compatible"], ], range: 2..=8, }; @@ -75774,6 +144116,17 @@ pub static WORD_COMPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -75803,11 +144156,22 @@ static WORD_COMPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st None, 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, @@ -75829,10 +144193,12 @@ pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"), @@ -75873,10 +144239,12 @@ pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["competed"], &["competition"], &["competitions"], + &["competitive"], &["competitor"], &["competitors"], &["competitor"], - &["competition"], + &["competition", "completion"], + &["completions"], &["competitors"], &["competitively"], &["competitors"], @@ -75951,6 +144319,7 @@ static WORD_COMPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), @@ -75966,6 +144335,7 @@ pub static WORD_COMPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d ], values: &[ &["compendium"], + &["component", "competent"], &["components"], &["compendium"], &["compensation"], @@ -76001,19 +144371,25 @@ static WORD_COMPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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"), ], values: &[ &["compilation"], + &["completely"], &["complete"], &["completely"], + &["completely"], &["completes"], &["completing"], &["completion"], + &["completely"], ], range: 2..=5, }; @@ -76109,10 +144485,21 @@ static WORD_COMPA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static st 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, @@ -76120,13 +144507,35 @@ static WORD_COMPAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge 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("iability"), dictgen::InsensitiveStr::Ascii("iable"), + dictgen::InsensitiveStr::Ascii("iablity"), dictgen::InsensitiveStr::Ascii("ibel"), dictgen::InsensitiveStr::Ascii("ibil"), dictgen::InsensitiveStr::Ascii("ibile"), @@ -76135,20 +144544,49 @@ pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], + &["compatibility"], + &["compatible"], + &["compatibility"], &["compatible"], &["compatible"], &["compatible"], - &["compatible"], + &["compatibility"], + &["compatibility"], &["compatibility"], &["compatibility"], &["compatibility"], @@ -76156,8 +144594,11 @@ pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["compatibility"], &["compatibilities"], &["compatibility"], + &["compaction"], + &["compatibility"], + &["compatible"], ], - range: 4..=9, + range: 3..=9, }; static WORD_COMPAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76182,86 +144623,300 @@ pub static WORD_COMPAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d }; static WORD_COMPAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_COMPAR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_COMPAR_CHILDREN), value: None, }; -pub static WORD_COMPAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[ - dictgen::InsensitiveStr::Ascii("abil"), - dictgen::InsensitiveStr::Ascii("abile"), - dictgen::InsensitiveStr::Ascii("asion"), - dictgen::InsensitiveStr::Ascii("ason"), - dictgen::InsensitiveStr::Ascii("asons"), - dictgen::InsensitiveStr::Ascii("aste"), - dictgen::InsensitiveStr::Ascii("atie"), - dictgen::InsensitiveStr::Ascii("ativley"), - dictgen::InsensitiveStr::Ascii("ativly"), - dictgen::InsensitiveStr::Ascii("eble"), - dictgen::InsensitiveStr::Ascii("ement"), - dictgen::InsensitiveStr::Ascii("emos"), - dictgen::InsensitiveStr::Ascii("etive"), - dictgen::InsensitiveStr::Ascii("etively"), - dictgen::InsensitiveStr::Ascii("ions"), - dictgen::InsensitiveStr::Ascii("iosn"), - dictgen::InsensitiveStr::Ascii("isen"), - dictgen::InsensitiveStr::Ascii("ision"), - dictgen::InsensitiveStr::Ascii("isions"), - dictgen::InsensitiveStr::Ascii("isn"), - dictgen::InsensitiveStr::Ascii("ission"), - dictgen::InsensitiveStr::Ascii("isson"), - dictgen::InsensitiveStr::Ascii("issons"), - dictgen::InsensitiveStr::Ascii("itave"), - dictgen::InsensitiveStr::Ascii("itavely"), - dictgen::InsensitiveStr::Ascii("itive"), - dictgen::InsensitiveStr::Ascii("itively"), - dictgen::InsensitiveStr::Ascii("itve"), - dictgen::InsensitiveStr::Ascii("se"), - dictgen::InsensitiveStr::Ascii("sion"), - dictgen::InsensitiveStr::Ascii("sions"), - dictgen::InsensitiveStr::Ascii("te"), - dictgen::InsensitiveStr::Ascii("tent"), - dictgen::InsensitiveStr::Ascii("tmet"), - ], - values: &[ - &["comparable"], - &["comparable"], - &["comparison"], - &["comparison"], - &["comparisons"], - &["compares"], - &["comparative"], - &["comparatively"], - &["comparatively"], - &["comparable"], - &["compartment"], - &["compares"], - &["comparative"], - &["comparatively"], - &["comparison"], - &["comparisons"], - &["compares"], - &["comparison"], - &["comparisons"], - &["comparisons"], - &["comparisons"], - &["comparisons"], - &["comparisons"], - &["comparative"], - &["comparatively"], - &["comparative"], - &["comparatively"], - &["comparative"], - &["compares"], - &["comparison"], - &["comparisons"], - &["compare"], - &["compartment"], - &["compartment"], - ], - range: 2..=7, +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("ison"), + dictgen::InsensitiveStr::Ascii("isons"), + dictgen::InsensitiveStr::Ascii("ment"), + dictgen::InsensitiveStr::Ascii("mos"), + dictgen::InsensitiveStr::Ascii("tive"), + dictgen::InsensitiveStr::Ascii("tively"), + ], + values: &[ + &["comparable"], + &["comparable"], + &["comparison"], + &["comparisons"], + &["compartment"], + &["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("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"], + &["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, @@ -76275,8 +144930,10 @@ pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d 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"], @@ -76285,10 +144942,12 @@ pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = d &["companions"], &["compensate"], &["compensated"], + &["compensates"], &["compensating"], &["compensation"], + &["compensations"], ], - range: 2..=6, + range: 2..=7, }; static WORD_COMPAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76319,12 +144978,34 @@ static WORD_COMPAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge pub static WORD_COMPAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("bility"), + 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: &[&["companies"], &["companions"], &["comparison"]], - range: 3..=4, + values: &[ + &["compatibility"], + &["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 { @@ -76333,9 +145014,13 @@ static WORD_COMPAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_COMPAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("nons")], - values: &[&["companions"]], - range: 4..=4, + 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 { @@ -76358,9 +145043,53 @@ static WORD_COMPAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictge }; pub static WORD_COMPAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ility")], - values: &[&["compatibility"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("ility"), + dictgen::InsensitiveStr::Ascii("illity"), + dictgen::InsensitiveStr::Ascii("itility"), + ], + values: &[&["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("r"), + ], + values: &[&["common"], &["component"], &["color"]], + range: 1..=4, +}; + +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 { @@ -76382,9 +145111,9 @@ static WORD_COMM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_COMMM_NODE), - None, + Some(&WORD_COMMN_NODE), Some(&WORD_COMMO_NODE), - None, + Some(&WORD_COMMP_NODE), None, None, None, @@ -76404,10 +145133,12 @@ static WORD_COMMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("ncation"), dictgen::InsensitiveStr::Ascii("nciate"), dictgen::InsensitiveStr::Ascii("nciated"), dictgen::InsensitiveStr::Ascii("nciation"), @@ -76415,6 +145146,7 @@ pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -76432,23 +145164,32 @@ pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("nters"), + dictgen::InsensitiveStr::Ascii("nuication"), + dictgen::InsensitiveStr::Ascii("tated"), + dictgen::InsensitiveStr::Ascii("tating"), + dictgen::InsensitiveStr::Ascii("tive"), ], values: &[ - &["communications"], - &["communicated"], - &["communications"], - &["communications"], - &["communicate"], - &["communicated"], &["communication"], &["communications"], - &["communications"], - &["communication"], &["communicated"], + &["communications"], + &["communications"], &["communication"], &["communicate"], + &["communicated"], + &["communication"], + &["communications"], + &["communications"], + &["communication"], + &["communicated"], + &["communication"], + &["communication"], + &["communicate", "communication"], &["communications"], &["communications"], &["communication"], @@ -76464,8 +145205,14 @@ pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["communities"], &["communities"], &["communist"], + &["community"], + &["community"], &["communism"], &["commenters"], + &["communication"], + &["commuted"], + &["commuting"], + &["commutative"], ], range: 3..=10, }; @@ -76476,9 +145223,100 @@ static WORD_COMMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_COMMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iment")], - values: &[&["commitments"]], - range: 5..=5, + 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 { @@ -76490,12 +145328,17 @@ pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -76504,18 +145347,76 @@ pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di values: &[ &["commodities"], &["commodities"], + &["commodity"], &["commodities"], + &["common"], &["commonplace"], &["commonwealth"], + &["command"], &["commonly"], &["commonwealth"], &["commonplace"], + &["common", "comment"], + &["commonly"], &["commonwealth"], &["commonwealth"], &["commonwealth"], &["commonwealth"], ], - range: 4..=7, + 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("etary"), + dictgen::InsensitiveStr::Ascii("ication"), + 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"], + &["commentary"], + &["communication"], + &["comment"], + &["commented"], + &["commutative"], + &["communicating"], + &["communication"], + &["community"], + ], + range: 1..=9, }; static WORD_COMMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76525,11 +145426,62 @@ static WORD_COMMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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: &[&["command"], &["commemorated"]], - range: 3..=8, + 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 { @@ -76540,12 +145492,15 @@ static WORD_COMMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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"), @@ -76553,6 +145508,7 @@ pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -76561,29 +145517,42 @@ pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("tish"), 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"], &["communists"], + &["community"], &["communicate"], - &["communications"], + &["communicating"], + &["communications", "communication"], &["commissioned"], &["commissioner"], &["commission"], @@ -76591,6 +145560,7 @@ pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["commissioner"], &["commissioning"], &["commissions"], + &["commissions"], &["commissioner"], &["commissions"], &["commissioned"], @@ -76598,21 +145568,31 @@ pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["commissioner"], &["commissions"], &["commissions"], + &["committable"], &["committed"], &["committed"], &["committee"], &["committed"], + &["committer"], + &["committers"], &["commits"], &["committed"], + &["committee", "committing", "commit"], &["committing"], + &["committing"], + &["committish"], &["commitments"], + &["commit"], &["committee"], + &["committee"], + &["committees"], &["commitment"], &["commitments"], &["commits"], + &["committee"], &["commits"], ], - range: 2..=8, + range: 1..=8, }; static WORD_COMME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76623,16 +145603,26 @@ static WORD_COMME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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("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"), @@ -76661,19 +145651,30 @@ pub static WORD_COMME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ricial"), dictgen::InsensitiveStr::Ascii("ricially"), dictgen::InsensitiveStr::Ascii("rorative"), + dictgen::InsensitiveStr::Ascii("ted"), ], values: &[ &["commence"], + &["connect"], + &["connected"], + &["connecting"], + &["connectivity"], &["comedic"], &["commemorative"], &["commemorate"], &["commemorating"], &["commenters"], + &["commend", "comment", "common"], &["commerce"], &["commence"], &["commandment"], &["commandments"], + &["comment"], + &["commented"], + &["commented"], + &["comments", "commons"], &["commenters"], + &["commentstatus"], &["commentary"], &["commentator"], &["commenter"], @@ -76702,8 +145703,9 @@ pub static WORD_COMME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["commercial"], &["commercially"], &["commemorative"], + &["commented", "competed"], ], - range: 2..=9, + range: 1..=9, }; static WORD_COMMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76713,6 +145715,12 @@ static WORD_COMMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen 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"), @@ -76720,17 +145728,31 @@ pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"], &["commando"], &["commanded"], &["commandment"], @@ -76738,17 +145760,68 @@ pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["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: 2..=7, + 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"), + ], + values: &[ + &["complain"], + &["complained"], + &["complainer"], + &["complaining"], + &["complains"], + &["complaint"], + &["complaints"], + &["complete"], + &["completed"], + &["completely"], + &["completion"], + &["completely"], + &["complex"], + &["complexity"], + &["completer"], + ], + range: 2..=6, }; static WORD_COMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76758,6 +145831,9 @@ static WORD_COMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_COMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("led"), + dictgen::InsensitiveStr::Ascii("lers"), + dictgen::InsensitiveStr::Ascii("nation"), dictgen::InsensitiveStr::Ascii("sion"), dictgen::InsensitiveStr::Ascii("sioned"), dictgen::InsensitiveStr::Ascii("sioner"), @@ -76768,13 +145844,23 @@ pub static WORD_COMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ts"), + dictgen::InsensitiveStr::Ascii("tte"), dictgen::InsensitiveStr::Ascii("tted"), dictgen::InsensitiveStr::Ascii("ttee"), + dictgen::InsensitiveStr::Ascii("ttees"), + dictgen::InsensitiveStr::Ascii("tter"), dictgen::InsensitiveStr::Ascii("tting"), + dictgen::InsensitiveStr::Ascii("ttish"), ], values: &[ + &["compiled"], + &["compilers"], + &["combination"], &["commission"], &["commissioned"], &["commissioner"], @@ -76785,13 +145871,20 @@ pub static WORD_COMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["commissioner"], &["commissioning"], &["commissions"], - &["committed"], - &["committing"], + &["commit"], &["committed"], &["committee"], &["committing"], + &["commits"], + &["committed", "committee"], + &["committed"], + &["committee"], + &["committees"], + &["committer"], + &["committing"], + &["committish"], ], - range: 3..=8, + range: 1..=8, }; static WORD_COMF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76804,7 +145897,10 @@ pub static WORD_COMF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), @@ -76823,7 +145919,10 @@ pub static WORD_COMF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["comfortable"], &["comfortably"], &["comforting"], + &["confirm"], &["confirmation"], + &["conflicting"], + &["conformance"], &["comforting"], &["comfortably"], &["comfortably"], @@ -76838,7 +145937,7 @@ pub static WORD_COMF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["comfortable"], &["comfortably"], ], - range: 6..=11, + range: 3..=11, }; static WORD_COME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76848,12 +145947,21 @@ static WORD_COME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -76862,14 +145970,24 @@ pub static WORD_COME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ptitors"), 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"], @@ -76878,8 +145996,9 @@ pub static WORD_COME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["competitors"], &["cosmetic"], &["cosmetics"], + &["commented", "competed"], ], - range: 4..=9, + range: 2..=9, }; static WORD_COMD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76896,6 +146015,17 @@ pub static WORD_COMD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -76904,23 +146034,36 @@ static WORD_COMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("inig"), + dictgen::InsensitiveStr::Ascii("inine"), dictgen::InsensitiveStr::Ascii("inining"), dictgen::InsensitiveStr::Ascii("ins"), dictgen::InsensitiveStr::Ascii("onation"), @@ -76929,30 +146072,43 @@ pub static WORD_COMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], 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"], &["combining"], + &["combine"], &["combining"], &["combines"], &["combination"], &["combinations"], &["combustion"], ], - range: 3..=9, + range: 3..=10, }; static WORD_COMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -76963,41 +146119,67 @@ static WORD_COMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("nder"), dictgen::InsensitiveStr::Ascii("ndo"), dictgen::InsensitiveStr::Ascii("ndos"), dictgen::InsensitiveStr::Ascii("ny"), dictgen::InsensitiveStr::Ascii("pany"), + 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("ptible"), + dictgen::InsensitiveStr::Ascii("rators"), dictgen::InsensitiveStr::Ascii("rde"), ], values: &[ &["comrades"], - &["commander"], + &["command"], + &["command"], + &["commanded"], + &["commanding"], + &["commandline"], + &["commands"], + &["command"], + &["commander", "commandeer"], &["commando"], &["commandos"], &["company"], &["company"], + &["compared"], + &["compatibility"], + &["compatible"], + &["completion"], &["companies"], &["companions"], &["company"], &["comparable"], &["compare"], &["compares"], + &["comparing"], &["comparison"], &["comparisons"], &["compatible"], + &["comparators"], &["comrade"], ], - range: 2..=7, + range: 2..=10, }; static WORD_COL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77009,22 +146191,22 @@ static WORD_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_COLA_NODE), None, None, - None, + Some(&WORD_COLD_NODE), Some(&WORD_COLE_NODE), None, Some(&WORD_COLG_NODE), None, - None, + Some(&WORD_COLI_NODE), None, None, Some(&WORD_COLL_NODE), - None, + Some(&WORD_COLM_NODE), None, Some(&WORD_COLO_NODE), None, None, None, - None, + Some(&WORD_COLS_NODE), None, Some(&WORD_COLU_NODE), None, @@ -77042,19 +146224,44 @@ static WORD_COLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_COLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("bmia"), + dictgen::InsensitiveStr::Ascii("m"), dictgen::InsensitiveStr::Ascii("mbidae"), dictgen::InsensitiveStr::Ascii("mbina"), + dictgen::InsensitiveStr::Ascii("mmn"), + dictgen::InsensitiveStr::Ascii("mmns"), dictgen::InsensitiveStr::Ascii("mnas"), + dictgen::InsensitiveStr::Ascii("mnular"), + dictgen::InsensitiveStr::Ascii("ms"), dictgen::InsensitiveStr::Ascii("msn"), + dictgen::InsensitiveStr::Ascii("nn"), + dictgen::InsensitiveStr::Ascii("nns"), ], values: &[ &["columbia"], + &["column"], &["columbia"], &["columbia"], + &["column"], &["columns"], &["columns"], + &["columnar"], + &["columns"], + &["columns"], + &["column", "colon"], + &["columns"], ], - range: 3..=6, + 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 { @@ -77065,9 +146272,15 @@ static WORD_COLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("gen"), dictgen::InsensitiveStr::Ascii("mba"), dictgen::InsensitiveStr::Ascii("mbina"), + dictgen::InsensitiveStr::Ascii("mns"), dictgen::InsensitiveStr::Ascii("nge"), dictgen::InsensitiveStr::Ascii("nialisim"), dictgen::InsensitiveStr::Ascii("nializm"), @@ -77081,14 +146294,33 @@ pub static WORD_COLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["cologne"], &["colombia"], &["colombia"], + &["columns"], &["cologne"], &["colonialism"], &["colonialism"], @@ -77102,10 +146334,38 @@ pub static WORD_COLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["colorado"], &["colorblind"], &["colorado"], + &["colorful", "colorfully"], + &["coloring"], + &["colorizer"], + &["colorspace"], + &["colorspaces"], + &["close"], &["colorblind"], + &["column"], + &["column"], + &["columns"], + &["columns"], &["coloured"], + &["colourful", "colourfully"], + &["colourspace"], + &["colourspaces"], ], - range: 3..=8, + 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 { @@ -77125,14 +146385,14 @@ static WORD_COLL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str Some(&WORD_COLLI_NODE), None, None, - None, + Some(&WORD_COLLL_NODE), None, None, Some(&WORD_COLLO_NODE), Some(&WORD_COLLP_NODE), None, None, - None, + Some(&WORD_COLLS_NODE), None, Some(&WORD_COLLU_NODE), None, @@ -77148,9 +146408,23 @@ static WORD_COLLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen }; pub static WORD_COLLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("mn")], - values: &[&["column"]], - range: 2..=2, + 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("ions")], + values: &[&["collisions"]], + range: 4..=4, }; static WORD_COLLP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77184,29 +146458,44 @@ pub static WORD_COLLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("barate"), dictgen::InsensitiveStr::Ascii("baration"), dictgen::InsensitiveStr::Ascii("borate"), + dictgen::InsensitiveStr::Ascii("calized"), dictgen::InsensitiveStr::Ascii("nade"), 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"], &["colonnade"], &["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, @@ -77216,6 +146505,8 @@ pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di keys: &[ dictgen::InsensitiveStr::Ascii("quial"), dictgen::InsensitiveStr::Ascii("sin"), + dictgen::InsensitiveStr::Ascii("son"), + dictgen::InsensitiveStr::Ascii("sons"), dictgen::InsensitiveStr::Ascii("ssion"), dictgen::InsensitiveStr::Ascii("sson"), dictgen::InsensitiveStr::Ascii("tions"), @@ -77223,7 +146514,9 @@ pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di values: &[ &["colloquial"], &["collisions"], - &["collisions"], + &["collision", "collusion"], + &["collisions", "collusion", "collusions"], + &["collisions", "collision", "collusion"], &["collisions"], &["collisions"], ], @@ -77240,6 +146533,9 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("age"), 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("cte"), dictgen::InsensitiveStr::Ascii("ctems"), @@ -77249,6 +146545,7 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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"), @@ -77261,18 +146558,24 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ctons"), dictgen::InsensitiveStr::Ascii("ctos"), dictgen::InsensitiveStr::Ascii("ctros"), + dictgen::InsensitiveStr::Ascii("ection"), dictgen::InsensitiveStr::Ascii("gaue"), dictgen::InsensitiveStr::Ascii("gaues"), dictgen::InsensitiveStr::Ascii("gue"), dictgen::InsensitiveStr::Ascii("gues"), + dictgen::InsensitiveStr::Ascii("ktion"), dictgen::InsensitiveStr::Ascii("quial"), dictgen::InsensitiveStr::Ascii("st"), dictgen::InsensitiveStr::Ascii("teral"), + dictgen::InsensitiveStr::Ascii("tion"), ], values: &[ &["colleagues"], &["colleague"], &["colleagues"], + &["collecting"], + &["collection"], + &["collections"], &["collection"], &["collective"], &["collects"], @@ -77282,6 +146585,7 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["collects"], &["collective"], &["collects"], + &["collection"], &["collections"], &["collectively"], &["collectively"], @@ -77294,13 +146598,16 @@ pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["collections"], &["collectors"], &["collects"], + &["collection"], &["colleague"], &["colleagues"], &["colleague"], &["colleagues"], + &["collection"], &["colloquial"], &["collects"], &["collateral"], + &["collection"], ], range: 2..=8, }; @@ -77336,14 +146643,18 @@ pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("borato"), dictgen::InsensitiveStr::Ascii("boratore"), dictgen::InsensitiveStr::Ascii("bore"), + dictgen::InsensitiveStr::Ascii("ction"), + dictgen::InsensitiveStr::Ascii("obrative"), dictgen::InsensitiveStr::Ascii("pe"), dictgen::InsensitiveStr::Ascii("pes"), + dictgen::InsensitiveStr::Ascii("psable"), dictgen::InsensitiveStr::Ascii("pseing"), dictgen::InsensitiveStr::Ascii("psers"), 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"), @@ -77351,6 +146662,7 @@ pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("taral"), dictgen::InsensitiveStr::Ascii("terial"), dictgen::InsensitiveStr::Ascii("terol"), + dictgen::InsensitiveStr::Ascii("tiong"), dictgen::InsensitiveStr::Ascii("toral"), ], values: &[ @@ -77367,14 +146679,18 @@ pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["collaboration"], &["collaborate"], &["collaborate"], + &["collection"], + &["collaborative"], &["collapse"], &["collapse"], + &["collapsible"], &["collapsing"], &["collapses"], &["colloquial"], &["collars"], &["collars"], &["collars"], + &["collision"], &["collapse"], &["collapsed"], &["collapses"], @@ -77382,11 +146698,26 @@ pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["collateral"], &["collateral"], &["collateral"], + &["collation"], &["collateral"], ], range: 2..=8, }; +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("sion"), + dictgen::InsensitiveStr::Ascii("ssion"), + ], + values: &[&["collision"], &["collision"]], + range: 4..=5, +}; + static WORD_COLG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_COLG_CHILDREN), value: None, @@ -77405,11 +146736,35 @@ static WORD_COLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_COLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cted"), + dictgen::InsensitiveStr::Ascii("ction"), + dictgen::InsensitiveStr::Ascii("lction"), dictgen::InsensitiveStr::Ascii("lctive"), dictgen::InsensitiveStr::Ascii("lctors"), + dictgen::InsensitiveStr::Ascii("rscheme"), + dictgen::InsensitiveStr::Ascii("scing"), ], - values: &[&["collective"], &["collectors"]], - range: 6..=6, + values: &[ + &["collected"], + &["collection"], + &["collection"], + &["collective"], + &["collectors"], + &["colorscheme"], + &["coalescing"], + ], + range: 4..=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 { @@ -77419,10 +146774,11 @@ static WORD_COLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_COLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("boration"), dictgen::InsensitiveStr::Ascii("borations"), dictgen::InsensitiveStr::Ascii("teral"), ], - values: &[&["collaborations"], &["collateral"]], + values: &[&["collaboration"], &["collaborations"], &["collateral"]], range: 5..=9, }; @@ -77433,6 +146789,7 @@ static WORD_COI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -77447,12 +146804,23 @@ pub static WORD_COI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -77467,12 +146835,22 @@ pub static WORD_COI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["coincide"], &["coincide"], &["coincidental"], + &["coinitialize"], + &["coincide"], + &["coincided"], &["coincidence"], + &["coincident"], &["coincidental"], &["coincidentally"], + &["coincides"], + &["coinciding"], + &["contain"], + &["contained"], + &["containing"], + &["contains"], &["counterpoint"], ], - range: 5..=11, + range: 2..=11, }; static WORD_COH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77481,9 +146859,21 @@ static WORD_COH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_COH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("esie")], - values: &[&["cohesive"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("erance"), + dictgen::InsensitiveStr::Ascii("erancy"), + dictgen::InsensitiveStr::Ascii("erant"), + dictgen::InsensitiveStr::Ascii("erantly"), + dictgen::InsensitiveStr::Ascii("esie"), + ], + values: &[ + &["coherence"], + &["coherency"], + &["coherent"], + &["coherently"], + &["cohesive"], + ], + range: 4..=7, }; static WORD_COG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77507,9 +146897,51 @@ static WORD_COF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_COF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("orm")], - values: &[&["conform"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("eee"), + 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"], + &["confidence"], + &["configuration"], + &["configure"], + &["configured"], + &["configures"], + &["configuring"], + &["confirm"], + &["confirmation"], + &["confirmations"], + &["confirmed"], + &["confirming"], + &["confirms"], + &["conform"], + &["confirm"], + &["confirmation"], + &["confirmations"], + &["confirmed"], + &["confirming"], + &["confirms"], + ], + range: 3..=9, }; static WORD_COE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77519,20 +146951,123 @@ static WORD_COE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], &["coefficient"], + &["coefficients"], + &["coefficient"], + &["coefficients"], + &["coefficient"], + &["coefficients"], + &["coefficient"], + &["coefficients"], + &["coalesce"], &["coincidental"], + &["coercible"], + &["coercion"], + &["coercion"], + &["coexist"], + &["coexistence"], + &["coexisted"], + &["coexistence"], + &["coexisting"], + &["coexists"], + &["coexist"], + &["coexistence"], + &["coexists"], + &["coexistence"], + &["coexist"], + &["coexistence"], + &["coexisted"], + &["coexistence"], + &["coexisting"], + &["coexists"], ], - range: 7..=9, + 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("eing"), + dictgen::InsensitiveStr::Ascii("epoitn"), + dictgen::InsensitiveStr::Ascii("esc"), + dictgen::InsensitiveStr::Ascii("espel"), + dictgen::InsensitiveStr::Ascii("esream"), + dictgen::InsensitiveStr::Ascii("itions"), + 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"], + &["coding"], + &["codepoint"], + &["codecs"], + &["codespell"], + &["codestream"], + &["conditions"], + &["conduct"], + &["conducted"], + &["conductor"], + &["conducting"], + &["conductor"], + &["conducts"], + ], + range: 2..=6, }; static WORD_COC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77542,6 +147077,7 @@ static WORD_COC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_COC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("cinele"), dictgen::InsensitiveStr::Ascii("karoches"), dictgen::InsensitiveStr::Ascii("katils"), dictgen::InsensitiveStr::Ascii("kraoches"), @@ -77552,8 +147088,12 @@ pub static WORD_COC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["cocktails"], &["cockroaches"], @@ -77564,19 +147104,335 @@ pub static WORD_COC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["cocktails"], &["cocktails"], &["cocktail"], + &["document"], + &["documentation"], + &["document"], ], - range: 4..=9, + range: 4..=10, }; -static WORD_COA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_COA_CHILDREN), +static WORD_COB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_COB_CHILDREN), value: None, }; -pub static WORD_COA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lese")], - values: &[&["coalesce"]], - range: 4..=4, +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, + None, + 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("ssing"), + ], + values: &[ + &["coalesce"], + &["coalescing"], + &["coalesce"], + &["coalesced"], + &["coalescence"], + &["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_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("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"], + &["console"], + &["consoles"], + &["contain"], + &["contains"], + &["center"], + ], + range: 1..=10, }; static WORD_CM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77585,9 +147441,21 @@ static WORD_CM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_CM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("oputer")], - values: &[&["computer"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("ak"), + dictgen::InsensitiveStr::Ascii("mands"), + dictgen::InsensitiveStr::Ascii("obination"), + dictgen::InsensitiveStr::Ascii("oputer"), + dictgen::InsensitiveStr::Ascii("oputers"), + ], + values: &[ + &["cmake"], + &["commands"], + &["combination"], + &["computer"], + &["computers"], + ], + range: 2..=9, }; static WORD_CL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77598,7 +147466,7 @@ static WORD_CL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_CLA_NODE), None, - None, + Some(&WORD_CLC_NODE), None, Some(&WORD_CLE_NODE), None, @@ -77607,14 +147475,14 @@ static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_CLI_NODE), None, None, - None, + Some(&WORD_CLL_NODE), None, None, Some(&WORD_CLO_NODE), None, None, None, - None, + Some(&WORD_CLS_NODE), None, Some(&WORD_CLU_NODE), None, @@ -77645,20 +147513,45 @@ static WORD_CLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("stred"), dictgen::InsensitiveStr::Ascii("tchign"), dictgen::InsensitiveStr::Ascii("thcing"), ], values: &[ + &["clause"], &["clauses"], &["clutching"], + &["clued", "clue"], + &["column"], + &["clumsily"], &["culprit"], + &["cluster"], + &["cluster"], + &["clustered"], &["clutching"], &["clutching"], ], - range: 4..=6, + 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("oe")], + values: &[&["close"]], + range: 2..=2, }; static WORD_CLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77668,13 +147561,83 @@ static WORD_CLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ack"), + dictgen::InsensitiveStr::Ascii("acks"), + 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("nez"), + dictgen::InsensitiveStr::Ascii("nning"), + dictgen::InsensitiveStr::Ascii("ry"), + dictgen::InsensitiveStr::Ascii("s"), dictgen::InsensitiveStr::Ascii("seing"), dictgen::InsensitiveStr::Ascii("seley"), + dictgen::InsensitiveStr::Ascii("sests"), + dictgen::InsensitiveStr::Ascii("sig"), dictgen::InsensitiveStr::Ascii("sley"), + dictgen::InsensitiveStr::Ascii("ssed"), + dictgen::InsensitiveStr::Ascii("ssing"), + dictgen::InsensitiveStr::Ascii("ude"), + dictgen::InsensitiveStr::Ascii("udes"), + dictgen::InsensitiveStr::Ascii("usre"), ], - values: &[&["closely"], &["closing"], &["closely"], &["closely"]], - range: 4..=5, + values: &[ + &["cloak"], + &["cloaks"], + &["clobbering"], + &["clocksource"], + &["closed", "clothes"], + &["closing"], + &["close"], + &["closed"], + &["closed"], + &["closing"], + &["closely"], + &["clones", "cloner"], + &["cloning"], + &["glory"], + &["close"], + &["closing"], + &["closely"], + &["closest", "closets"], + &["closing"], + &["closely"], + &["closed"], + &["closing"], + &["cloud"], + &["clouds"], + &["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 { @@ -77689,25 +147652,38 @@ pub static WORD_CLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ckare"), dictgen::InsensitiveStr::Ascii("ckbat"), dictgen::InsensitiveStr::Ascii("ckear"), + 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("nets"), dictgen::InsensitiveStr::Ascii("nicaly"), dictgen::InsensitiveStr::Ascii("nicas"), dictgen::InsensitiveStr::Ascii("nicos"), dictgen::InsensitiveStr::Ascii("pbaord"), dictgen::InsensitiveStr::Ascii("pboad"), + dictgen::InsensitiveStr::Ascii("poard"), + dictgen::InsensitiveStr::Ascii("poards"), + dictgen::InsensitiveStr::Ascii("poing"), dictgen::InsensitiveStr::Ascii("tiros"), dictgen::InsensitiveStr::Ascii("toridis"), dictgen::InsensitiveStr::Ascii("tories"), @@ -77715,6 +147691,8 @@ pub static WORD_CLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("torious"), dictgen::InsensitiveStr::Ascii("torius"), dictgen::InsensitiveStr::Ascii("tors"), + dictgen::InsensitiveStr::Ascii("uent"), + dictgen::InsensitiveStr::Ascii("uents"), ], values: &[ &["climates"], @@ -77723,24 +147701,37 @@ pub static WORD_CLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["clickbait"], &["clicker"], &["clients"], + &["client"], + &["client", "clientele"], + &["clientele"], + &["clients"], &["cliffhanger"], &["cliffhanger"], &["cliffhanger"], &["cliffhanger"], &["cliffhanger"], + &["click"], &["clickbait"], + &["clicks"], &["climates"], &["climates"], &["climates"], &["climbers"], + &["climber"], + &["climbers"], + &["climbing"], &["clinical"], &["clinically"], &["clinics"], + &["clients"], &["clinically"], &["clinics"], &["clinics"], &["clipboard"], &["clipboard"], + &["clipboard"], + &["clipboards"], + &["clipping"], &["clitoris"], &["clitoris"], &["clitoris"], @@ -77748,8 +147739,10 @@ pub static WORD_CLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["clitoris"], &["clitoris"], &["clitoris"], + &["client"], + &["clients"], ], - range: 4..=8, + range: 1..=8, }; static WORD_CLH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -77770,54 +147763,128 @@ static WORD_CLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("a"), + dictgen::InsensitiveStr::Ascii("aer"), + dictgen::InsensitiveStr::Ascii("aered"), + dictgen::InsensitiveStr::Ascii("aing"), + dictgen::InsensitiveStr::Ascii("ancacne"), + dictgen::InsensitiveStr::Ascii("and"), dictgen::InsensitiveStr::Ascii("anes"), + dictgen::InsensitiveStr::Ascii("aness"), dictgen::InsensitiveStr::Ascii("anies"), dictgen::InsensitiveStr::Ascii("anilness"), dictgen::InsensitiveStr::Ascii("anisng"), dictgen::InsensitiveStr::Ascii("anleness"), dictgen::InsensitiveStr::Ascii("anliess"), dictgen::InsensitiveStr::Ascii("anlyness"), + dictgen::InsensitiveStr::Ascii("anning"), + dictgen::InsensitiveStr::Ascii("annup"), + dictgen::InsensitiveStr::Ascii("anp"), + dictgen::InsensitiveStr::Ascii("anpu"), + dictgen::InsensitiveStr::Ascii("anpus"), dictgen::InsensitiveStr::Ascii("ansiness"), + dictgen::InsensitiveStr::Ascii("antup"), + dictgen::InsensitiveStr::Ascii("are"), dictgen::InsensitiveStr::Ascii("areance"), + dictgen::InsensitiveStr::Ascii("arified"), + dictgen::InsensitiveStr::Ascii("arifies"), + dictgen::InsensitiveStr::Ascii("arify"), + dictgen::InsensitiveStr::Ascii("arifying"), + dictgen::InsensitiveStr::Ascii("arling"), + dictgen::InsensitiveStr::Ascii("arnance"), + dictgen::InsensitiveStr::Ascii("arnances"), + dictgen::InsensitiveStr::Ascii("arted"), dictgen::InsensitiveStr::Ascii("asne"), dictgen::InsensitiveStr::Ascii("asner"), dictgen::InsensitiveStr::Ascii("asning"), + dictgen::InsensitiveStr::Ascii("ck"), + dictgen::InsensitiveStr::Ascii("ean"), + dictgen::InsensitiveStr::Ascii("ff"), + dictgen::InsensitiveStr::Ascii("int"), dictgen::InsensitiveStr::Ascii("ints"), dictgen::InsensitiveStr::Ascii("nase"), dictgen::InsensitiveStr::Ascii("naser"), + dictgen::InsensitiveStr::Ascii("r"), dictgen::InsensitiveStr::Ascii("ra"), dictgen::InsensitiveStr::Ascii("rification"), + dictgen::InsensitiveStr::Ascii("se"), + dictgen::InsensitiveStr::Ascii("ses"), dictgen::InsensitiveStr::Ascii("sius"), dictgen::InsensitiveStr::Ascii("tics"), dictgen::InsensitiveStr::Ascii("velry"), + dictgen::InsensitiveStr::Ascii("vely"), dictgen::InsensitiveStr::Ascii("verleys"), dictgen::InsensitiveStr::Ascii("very"), ], values: &[ + &["clean"], + &["clear", "clearer", "cleaner"], + &["cleared"], + &["cleaning"], + &["cleancache"], + &["cleaned", "cleans", "clean"], &["cleanse"], + &["cleanness"], &["cleanse"], &["cleanliness"], &["cleansing"], &["cleanliness"], &["cleanliness"], &["cleanliness"], + &["cleaning"], + &["cleanup"], + &["cleanup"], + &["cleanup"], + &["cleanups"], &["cleanliness"], + &["cleanup"], + &["cleared", "clear"], &["clearance"], + &["clarified"], + &["clarifies"], + &["clarify"], + &["clarifying"], + &["clearing"], + &["clearance"], + &["clearances"], + &["cleared"], &["cleanse"], &["cleanser"], &["cleansing"], + &["check"], + &["clean"], + &["clef"], + &["client"], &["clients"], &["cleanse"], &["cleanser"], &["clear"], + &["clear", "sclera"], &["clarification"], + &["close"], + &["closes"], &["celsius"], &["celtics"], &["cleverly"], &["cleverly"], &["cleverly"], + &["cleverly"], ], - range: 2..=10, + range: 1..=10, +}; + +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 { @@ -77827,7 +147894,10 @@ static WORD_CLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("aes"), dictgen::InsensitiveStr::Ascii("cium"), + dictgen::InsensitiveStr::Ascii("culate"), + dictgen::InsensitiveStr::Ascii("culation"), dictgen::InsensitiveStr::Ascii("culations"), dictgen::InsensitiveStr::Ascii("culator"), dictgen::InsensitiveStr::Ascii("culators"), @@ -77836,24 +147906,41 @@ pub static WORD_CLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("erly"), dictgen::InsensitiveStr::Ascii("gary"), dictgen::InsensitiveStr::Ascii("ibre"), + dictgen::InsensitiveStr::Ascii("ibscale"), + dictgen::InsensitiveStr::Ascii("ime"), dictgen::InsensitiveStr::Ascii("imes"), dictgen::InsensitiveStr::Ascii("irfy"), dictgen::InsensitiveStr::Ascii("irfying"), dictgen::InsensitiveStr::Ascii("irty"), + dictgen::InsensitiveStr::Ascii("me"), dictgen::InsensitiveStr::Ascii("nand"), dictgen::InsensitiveStr::Ascii("nnand"), + dictgen::InsensitiveStr::Ascii("read"), + dictgen::InsensitiveStr::Ascii("red"), + dictgen::InsensitiveStr::Ascii("rety"), dictgen::InsensitiveStr::Ascii("rfiy"), dictgen::InsensitiveStr::Ascii("rificaiton"), dictgen::InsensitiveStr::Ascii("rifiy"), + dictgen::InsensitiveStr::Ascii("ring"), dictgen::InsensitiveStr::Ascii("rskon"), dictgen::InsensitiveStr::Ascii("s"), dictgen::InsensitiveStr::Ascii("sic"), dictgen::InsensitiveStr::Ascii("sical"), dictgen::InsensitiveStr::Ascii("sically"), dictgen::InsensitiveStr::Ascii("sification"), + dictgen::InsensitiveStr::Ascii("sified"), + dictgen::InsensitiveStr::Ascii("sifies"), + dictgen::InsensitiveStr::Ascii("sify"), + dictgen::InsensitiveStr::Ascii("sifying"), + dictgen::InsensitiveStr::Ascii("sse"), + dictgen::InsensitiveStr::Ascii("ssess"), + dictgen::InsensitiveStr::Ascii("ssesss"), dictgen::InsensitiveStr::Ascii("ssicals"), dictgen::InsensitiveStr::Ascii("ssicos"), dictgen::InsensitiveStr::Ascii("ssicus"), + dictgen::InsensitiveStr::Ascii("ssifed"), + dictgen::InsensitiveStr::Ascii("ssifer"), + dictgen::InsensitiveStr::Ascii("ssifers"), dictgen::InsensitiveStr::Ascii("ssificaiton"), dictgen::InsensitiveStr::Ascii("ssificato"), dictgen::InsensitiveStr::Ascii("ssifides"), @@ -77861,14 +147948,21 @@ pub static WORD_CLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ssis"), dictgen::InsensitiveStr::Ascii("ssrom"), dictgen::InsensitiveStr::Ascii("ssrooom"), + dictgen::InsensitiveStr::Ascii("sss"), + dictgen::InsensitiveStr::Ascii("ssses"), dictgen::InsensitiveStr::Ascii("sssic"), dictgen::InsensitiveStr::Ascii("sues"), + dictgen::InsensitiveStr::Ascii("tified"), + dictgen::InsensitiveStr::Ascii("us"), dictgen::InsensitiveStr::Ascii("usens"), dictgen::InsensitiveStr::Ascii("ymer"), dictgen::InsensitiveStr::Ascii("ymoe"), ], values: &[ + &["classes"], &["calcium"], + &["calculate"], + &["calculation"], &["calculations"], &["calculator"], &["calculators"], @@ -77877,24 +147971,41 @@ pub static WORD_CLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["clearly"], &["calgary"], &["calibre"], + &["calibscale"], + &["claim"], &["claims"], &["clarify"], &["clarifying"], &["clarity"], + &["claim"], &["clannad"], &["clannad"], + &["cleared"], + &["cleared"], + &["clarity"], &["clarify"], &["clarification"], &["clarify"], + &["clearing"], &["clarkson"], &["class"], &["classic"], &["classical"], &["classically"], - &["clarification"], + &["clarification", "classification"], + &["classified"], + &["classifies"], + &["classify"], + &["classifying"], + &["class", "classes"], + &["classes"], + &["classes"], &["classics"], &["classics"], &["classics"], + &["classified"], + &["classifier"], + &["classifiers"], &["classification"], &["classification"], &["classified"], @@ -77902,8 +148013,12 @@ pub static WORD_CLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["classics"], &["classroom"], &["classroom"], + &["class"], + &["classes"], &["classics"], &["clauses"], + &["clarified"], + &["clause"], &["clauses"], &["claymore"], &["claymore"], @@ -77911,6 +148026,40 @@ pub static WORD_CLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 1..=11, }; +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("ecksum")], + values: &[&["checksum"]], + range: 6..=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, @@ -77924,15 +148073,15 @@ static WORD_CI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_CIE_NODE), None, Some(&WORD_CIG_NODE), - None, + Some(&WORD_CIH_NODE), None, None, None, Some(&WORD_CIL_NODE), None, Some(&WORD_CIN_NODE), - None, - None, + Some(&WORD_CIO_NODE), + Some(&WORD_CIP_NODE), None, Some(&WORD_CIR_NODE), None, @@ -77963,6 +148112,7 @@ pub static WORD_CIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ilizaton"), dictgen::InsensitiveStr::Ascii("ilizatons"), dictgen::InsensitiveStr::Ascii("illian"), + dictgen::InsensitiveStr::Ascii("illians"), dictgen::InsensitiveStr::Ascii("ilziation"), dictgen::InsensitiveStr::Ascii("izilation"), ], @@ -77978,6 +148128,7 @@ pub static WORD_CIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["civilization"], &["civilizations"], &["civilian"], + &["civilians"], &["civilizations"], &["civilizations"], ], @@ -78000,142 +148151,481 @@ pub static WORD_CIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_CIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CIR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CIR_CHILDREN), value: None, }; -pub static WORD_CIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("cels"), - dictgen::InsensitiveStr::Ascii("cimcised"), - dictgen::InsensitiveStr::Ascii("ciuts"), - dictgen::InsensitiveStr::Ascii("ckets"), - dictgen::InsensitiveStr::Ascii("clebs"), - dictgen::InsensitiveStr::Ascii("cluar"), - dictgen::InsensitiveStr::Ascii("cluating"), - dictgen::InsensitiveStr::Ascii("comference"), - dictgen::InsensitiveStr::Ascii("cualtion"), - dictgen::InsensitiveStr::Ascii("cuis"), - dictgen::InsensitiveStr::Ascii("cuitos"), - dictgen::InsensitiveStr::Ascii("culacion"), - dictgen::InsensitiveStr::Ascii("culaire"), - dictgen::InsensitiveStr::Ascii("culatiing"), - dictgen::InsensitiveStr::Ascii("culationg"), - dictgen::InsensitiveStr::Ascii("culaton"), - dictgen::InsensitiveStr::Ascii("cumcisied"), - dictgen::InsensitiveStr::Ascii("cumcison"), - dictgen::InsensitiveStr::Ascii("cumcission"), - dictgen::InsensitiveStr::Ascii("cumcition"), - dictgen::InsensitiveStr::Ascii("cumferance"), - dictgen::InsensitiveStr::Ascii("cumsice"), - dictgen::InsensitiveStr::Ascii("cumsiced"), - dictgen::InsensitiveStr::Ascii("cumsicion"), - dictgen::InsensitiveStr::Ascii("cumsicions"), - dictgen::InsensitiveStr::Ascii("cumsied"), - dictgen::InsensitiveStr::Ascii("cumsised"), - dictgen::InsensitiveStr::Ascii("cumsision"), - dictgen::InsensitiveStr::Ascii("cumsition"), - dictgen::InsensitiveStr::Ascii("cumsizion"), - dictgen::InsensitiveStr::Ascii("cumstace"), - dictgen::InsensitiveStr::Ascii("cumstanes"), - dictgen::InsensitiveStr::Ascii("cumstanial"), - dictgen::InsensitiveStr::Ascii("cumstansial"), - dictgen::InsensitiveStr::Ascii("cumstanta"), - dictgen::InsensitiveStr::Ascii("cumstantal"), - dictgen::InsensitiveStr::Ascii("cumstante"), - dictgen::InsensitiveStr::Ascii("cumstantional"), - dictgen::InsensitiveStr::Ascii("cumstantual"), - dictgen::InsensitiveStr::Ascii("cumstential"), - dictgen::InsensitiveStr::Ascii("cumstnaces"), - dictgen::InsensitiveStr::Ascii("cumvrent"), - dictgen::InsensitiveStr::Ascii("cumwent"), - dictgen::InsensitiveStr::Ascii("cuncised"), - dictgen::InsensitiveStr::Ascii("cuncision"), - dictgen::InsensitiveStr::Ascii("cunference"), - dictgen::InsensitiveStr::Ascii("cunstance"), - dictgen::InsensitiveStr::Ascii("cunstances"), - dictgen::InsensitiveStr::Ascii("cunstantial"), - dictgen::InsensitiveStr::Ascii("cunvent"), - dictgen::InsensitiveStr::Ascii("cut"), - dictgen::InsensitiveStr::Ascii("icuit"), - dictgen::InsensitiveStr::Ascii("iculum"), - dictgen::InsensitiveStr::Ascii("lces"), - dictgen::InsensitiveStr::Ascii("lcing"), - dictgen::InsensitiveStr::Ascii("ruculum"), - dictgen::InsensitiveStr::Ascii("ticise"), - dictgen::InsensitiveStr::Ascii("ticising"), - dictgen::InsensitiveStr::Ascii("uclar"), - dictgen::InsensitiveStr::Ascii("uclating"), - dictgen::InsensitiveStr::Ascii("uclation"), - dictgen::InsensitiveStr::Ascii("ucmference"), - dictgen::InsensitiveStr::Ascii("ucmstances"), + dictgen::InsensitiveStr::Ascii("cal"), + dictgen::InsensitiveStr::Ascii("cit"), + 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: &[ - &["circles"], - &["circumcised"], - &["circuits"], - &["crickets"], - &["circles"], + &["circular"], + &["circuit"], &["circular"], &["circulating"], + &["circulation"], + &["circulator"], &["circumference"], - &["circulation"], - &["circuits"], - &["circuits"], - &["circulation"], + &["circumflex"], + &["circumstances"], &["circular"], - &["circulating"], - &["circulating"], - &["circulation"], - &["circumcised"], - &["circumcision"], - &["circumcision"], - &["circumcision"], - &["circumference"], - &["circumcised"], - &["circumcised"], - &["circumcision"], - &["circumcision"], - &["circumcised"], - &["circumcised"], - &["circumcision"], - &["circumcision"], - &["circumcision"], - &["circumstance"], - &["circumstance"], - &["circumstantial"], - &["circumstantial"], - &["circumstantial"], - &["circumstantial"], - &["circumstance"], - &["circumstantial"], - &["circumstantial"], - &["circumstantial"], - &["circumstance"], - &["circumvent"], - &["circumvent"], - &["circumcised"], - &["circumcision"], - &["circumference"], &["circumstance"], &["circumstances"], - &["circumstantial"], - &["circumvent"], &["circuit"], - &["circuit"], - &["curriculum"], - &["circles"], - &["circling"], - &["curriculum"], - &["criticise"], - &["criticising"], - &["circular"], - &["circulating"], - &["circulation"], - &["circumference"], + &["circuits"], + &["circumflex"], + &["circumstance"], &["circumstances"], ], - range: 3..=13, + 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("uculum")], + values: &[&["curriculum"]], + range: 6..=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("ces"), + dictgen::InsensitiveStr::Ascii("cing"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("es"), + ], + values: &[&["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("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"], + &["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("mvent"), + dictgen::InsensitiveStr::Ascii("mvented"), + dictgen::InsensitiveStr::Ascii("mvents"), + ], + values: &[ + &["circumference"], + &["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("uating"), + ], + values: &[&["circles"], &["circular"], &["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("uts"), + ], + values: &[&["circumcised"], &["circuits"]], + range: 3..=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")], + values: &[&["control"]], + range: 5..=5, }; static WORD_CIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -78157,8 +148647,11 @@ pub static WORD_CIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("taner"), ], values: &[ &["cincinnati"], @@ -78173,10 +148666,13 @@ pub static WORD_CIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["cinematography"], &["cinematography"], &["cinematography"], + &["configuration"], + &["configurations"], &["cinematography"], &["cincinnati"], + &["container"], ], - range: 7..=11, + range: 5..=11, }; static WORD_CIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -78187,7 +148683,12 @@ static WORD_CIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("anto"), + 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("ivians"), dictgen::InsensitiveStr::Ascii("ivization"), dictgen::InsensitiveStr::Ascii("mbers"), @@ -78195,10 +148696,18 @@ pub static WORD_CIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], - &["clients"], + &["client", "silent"], + &["clients", "silents", "silence"], + &["cylinder", "silencer"], + &["cylinders", "silencers"], + &["cylinder"], + &["cylinders"], &["civilians"], &["civilizations"], &["climbers"], @@ -78206,8 +148715,25 @@ pub static WORD_CIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["clipboard"], &["clitoris"], &["cylinders"], + &["cylinder"], + &["cylinders"], + &["cylinders"], ], - range: 4..=9, + 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 { @@ -78250,9 +148776,25 @@ static WORD_CIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_CIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rulating")], - values: &[&["circulating"]], - range: 8..=8, + 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 { @@ -78271,10 +148813,10 @@ static WORD_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_CHI_NODE), None, - None, + Some(&WORD_CHK_NODE), Some(&WORD_CHL_NODE), Some(&WORD_CHM_NODE), - None, + Some(&WORD_CHN_NODE), Some(&WORD_CHO_NODE), None, None, @@ -78298,11 +148840,34 @@ pub static WORD_CHU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("ch"), dictgen::InsensitiveStr::Ascii("ckels"), + dictgen::InsensitiveStr::Ascii("ks"), + dictgen::InsensitiveStr::Ascii("naks"), + 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"], &["churches"], &["churches"]], - range: 2..=6, + values: &[ + &["church"], + &["chuckles"], + &["chunks"], + &["chunks"], + &["chunk"], + &["chunked"], + &["chunking"], + &["chunks"], + &["chunksize"], + &["chunks"], + &["chunked"], + &["churches"], + &["churches"], + ], + range: 2..=7, }; static WORD_CHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -78324,6 +148889,14 @@ static WORD_CHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -78341,6 +148914,7 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -78358,6 +148932,7 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -78377,6 +148952,14 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["character"], + &["characters"], + &["character"], + &["characters"], + &["crash", "thrash", "trash"], + &["crashed", "thrashed", "trashed"], + &["crashes", "thrashes", "trashes"], + &["crashing", "thrashing", "trashing"], + &["crashes", "thrashes", "trashes"], &["chernobyl"], &["christian"], &["christianity"], @@ -78394,6 +148977,7 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["christians"], &["christians"], &["christians"], + &["chrominance"], &["chlorine"], &["chromosome"], &["chromosomes"], @@ -78411,6 +148995,7 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["chromosomes"], &["chromosome"], &["chromosomes"], + &["chromium"], &["chronicles"], &["chronicles"], &["chronicles"], @@ -78428,7 +149013,7 @@ pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["christmas"], &["churches"], ], - range: 5..=10, + range: 3..=10, }; static WORD_CHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -78441,6 +149026,7 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("atic"), dictgen::InsensitiveStr::Ascii("calates"), dictgen::InsensitiveStr::Ascii("cies"), + dictgen::InsensitiveStr::Ascii("clate"), dictgen::InsensitiveStr::Ascii("cloate"), dictgen::InsensitiveStr::Ascii("cloates"), dictgen::InsensitiveStr::Ascii("coalte"), @@ -78456,6 +149042,10 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -78463,18 +149053,31 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("ser"), + dictgen::InsensitiveStr::Ascii("sing"), + dictgen::InsensitiveStr::Ascii("ssen"), + dictgen::InsensitiveStr::Ascii("uld"), + dictgen::InsensitiveStr::Ascii("use"), ], values: &[ &["chaotic"], &["chocolates"], &["choices"], &["chocolate"], + &["chocolate"], &["chocolates"], &["chocolate"], &["chocolates"], @@ -78489,6 +149092,10 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["chocolates"], &["cohesive"], &["choices"], + &["choosing"], + &["choice"], + &["choices"], + &["choosing"], &["cholesterol"], &["cholesterol"], &["cholesterol"], @@ -78496,14 +149103,42 @@ pub static WORD_CHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["chocolate"], &["cholesterol"], &["chlorine"], + &["choose"], + &["choose"], + &["chose", "chosen"], &["chosen"], + &["chopping"], + &["choppy", "chop"], &["chlorine"], &["chromosome"], &["chromosomes"], &["chronicles"], &["chronological"], + &["chronological"], + &["chose"], + &["chooser"], + &["choosing"], + &["chosen"], + &["should", "could"], + &["choose", "chose", "choux"], ], - range: 4..=10, + 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("ages"), + dictgen::InsensitiveStr::Ascii("ge"), + dictgen::InsensitiveStr::Ascii("nel"), + ], + values: &[&["change"], &["changes"], &["change"], &["channel"]], + range: 2..=4, }; static WORD_CHM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -78542,6 +149177,17 @@ pub static WORD_CHL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 4..=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::Flat(&WORD_CHI_CHILDREN), value: None, @@ -78554,6 +149200,7 @@ pub static WORD_CHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("dlfree"), dictgen::InsensitiveStr::Ascii("dlish"), dictgen::InsensitiveStr::Ascii("dlrens"), + dictgen::InsensitiveStr::Ascii("dren"), dictgen::InsensitiveStr::Ascii("ense"), dictgen::InsensitiveStr::Ascii("hauhua"), dictgen::InsensitiveStr::Ascii("huaha"), @@ -78563,29 +149210,47 @@ pub static WORD_CHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ldbird"), dictgen::InsensitiveStr::Ascii("ldbrith"), dictgen::InsensitiveStr::Ascii("lden"), + dictgen::InsensitiveStr::Ascii("ldern"), dictgen::InsensitiveStr::Ascii("lderns"), dictgen::InsensitiveStr::Ascii("ldisch"), + dictgen::InsensitiveStr::Ascii("ldlren"), dictgen::InsensitiveStr::Ascii("ldrends"), dictgen::InsensitiveStr::Ascii("ldrenis"), dictgen::InsensitiveStr::Ascii("ldrenmrs"), dictgen::InsensitiveStr::Ascii("ldrents"), dictgen::InsensitiveStr::Ascii("ldres"), dictgen::InsensitiveStr::Ascii("ldresn"), + dictgen::InsensitiveStr::Ascii("lds"), + dictgen::InsensitiveStr::Ascii("led"), + dictgen::InsensitiveStr::Ascii("ledren"), dictgen::InsensitiveStr::Ascii("llade"), dictgen::InsensitiveStr::Ascii("llead"), dictgen::InsensitiveStr::Ascii("llend"), + dictgen::InsensitiveStr::Ascii("lren"), dictgen::InsensitiveStr::Ascii("lvary"), dictgen::InsensitiveStr::Ascii("meny"), dictgen::InsensitiveStr::Ascii("nees"), + dictgen::InsensitiveStr::Ascii("neese"), dictgen::InsensitiveStr::Ascii("nesse"), dictgen::InsensitiveStr::Ascii("nmey"), + dictgen::InsensitiveStr::Ascii("op"), + dictgen::InsensitiveStr::Ascii("per"), + dictgen::InsensitiveStr::Ascii("pers"), + dictgen::InsensitiveStr::Ascii("persuite"), + dictgen::InsensitiveStr::Ascii("persuites"), + dictgen::InsensitiveStr::Ascii("pertext"), + dictgen::InsensitiveStr::Ascii("pertexts"), dictgen::InsensitiveStr::Ascii("pest"), + dictgen::InsensitiveStr::Ascii("pet"), + dictgen::InsensitiveStr::Ascii("pslect"), + dictgen::InsensitiveStr::Ascii("pstes"), dictgen::InsensitiveStr::Ascii("rstian"), dictgen::InsensitiveStr::Ascii("rstianity"), dictgen::InsensitiveStr::Ascii("rstians"), dictgen::InsensitiveStr::Ascii("rstmas"), dictgen::InsensitiveStr::Ascii("spet"), dictgen::InsensitiveStr::Ascii("uhahua"), + dictgen::InsensitiveStr::Ascii("uldren"), dictgen::InsensitiveStr::Ascii("valy"), dictgen::InsensitiveStr::Ascii("varly"), dictgen::InsensitiveStr::Ascii("vlary"), @@ -78596,6 +149261,7 @@ pub static WORD_CHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["childfree"], &["childish"], &["childrens"], + &["children"], &["chinese"], &["chihuahua"], &["chihuahua"], @@ -78605,195 +149271,81 @@ pub static WORD_CHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["childbirth"], &["childbirth"], &["children"], + &["children"], &["childrens"], &["childish"], + &["children"], &["childrens"], &["childrens"], &["childrens"], &["childrens"], + &["childrens", "children"], &["childrens"], - &["childrens"], + &["children"], + &["child", "chilled"], + &["children"], &["chilled"], &["chilled"], &["chilled"], + &["children"], &["chivalry"], &["chimney"], &["chinese"], &["chinese"], + &["chinese"], &["chimney"], + &["chip", "chop"], + &["cipher", "chipper", "chimer"], + &["ciphers", "chippers", "chimers"], + &["ciphersuite"], + &["ciphersuites"], + &["ciphertext"], + &["ciphertexts"], &["chipset"], + &["chipset"], + &["chipselect"], + &["chipsets"], &["christian"], &["christianity"], &["christians"], &["christmas"], &["chipset"], &["chihuahua"], + &["children"], &["chivalry"], &["chivalry"], &["chivalry"], ], - range: 4..=9, + range: 2..=9, }; static WORD_CHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CHE_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CHE_CHILDREN), value: None, }; -pub static WORD_CHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[ - dictgen::InsensitiveStr::Ascii("chpoint"), - dictgen::InsensitiveStr::Ascii("ckare"), - dictgen::InsensitiveStr::Ascii("ckear"), - dictgen::InsensitiveStr::Ascii("ckmeat"), - dictgen::InsensitiveStr::Ascii("ckpiont"), - dictgen::InsensitiveStr::Ascii("ckpoins"), - dictgen::InsensitiveStr::Ascii("ckpointusa"), - dictgen::InsensitiveStr::Ascii("ckpoit"), - dictgen::InsensitiveStr::Ascii("ckponts"), - dictgen::InsensitiveStr::Ascii("eots"), - dictgen::InsensitiveStr::Ascii("erleadra"), - dictgen::InsensitiveStr::Ascii("erlearder"), - dictgen::InsensitiveStr::Ascii("erleards"), - dictgen::InsensitiveStr::Ascii("erleeder"), - dictgen::InsensitiveStr::Ascii("erleeders"), - dictgen::InsensitiveStr::Ascii("eseberger"), - dictgen::InsensitiveStr::Ascii("eseborger"), - dictgen::InsensitiveStr::Ascii("esebruger"), - dictgen::InsensitiveStr::Ascii("esebuger"), - dictgen::InsensitiveStr::Ascii("eseburgare"), - dictgen::InsensitiveStr::Ascii("eseburges"), - dictgen::InsensitiveStr::Ascii("eseburgie"), - dictgen::InsensitiveStr::Ascii("eseburgler"), - dictgen::InsensitiveStr::Ascii("eseburgs"), - dictgen::InsensitiveStr::Ascii("eseburguer"), - dictgen::InsensitiveStr::Ascii("eseburguers"), - dictgen::InsensitiveStr::Ascii("esecase"), - dictgen::InsensitiveStr::Ascii("esecave"), - dictgen::InsensitiveStr::Ascii("esees"), - dictgen::InsensitiveStr::Ascii("eseface"), - dictgen::InsensitiveStr::Ascii("eseus"), - dictgen::InsensitiveStr::Ascii("esse"), - dictgen::InsensitiveStr::Ascii("etoos"), - dictgen::InsensitiveStr::Ascii("ezeburger"), - dictgen::InsensitiveStr::Ascii("ezeburgers"), - dictgen::InsensitiveStr::Ascii("ezecake"), - dictgen::InsensitiveStr::Ascii("if"), - dictgen::InsensitiveStr::Ascii("ifs"), - dictgen::InsensitiveStr::Ascii("kcer"), - dictgen::InsensitiveStr::Ascii("kcmate"), - dictgen::InsensitiveStr::Ascii("lsae"), - dictgen::InsensitiveStr::Ascii("mcial"), - dictgen::InsensitiveStr::Ascii("mcially"), - dictgen::InsensitiveStr::Ascii("mestry"), - dictgen::InsensitiveStr::Ascii("micaly"), - dictgen::InsensitiveStr::Ascii("misty"), - dictgen::InsensitiveStr::Ascii("msitry"), - dictgen::InsensitiveStr::Ascii("rnboyl"), - dictgen::InsensitiveStr::Ascii("rnobl"), - dictgen::InsensitiveStr::Ascii("rnobly"), - dictgen::InsensitiveStr::Ascii("rnoybl"), - dictgen::InsensitiveStr::Ascii("rnyobl"), - dictgen::InsensitiveStr::Ascii("ronbyl"), - dictgen::InsensitiveStr::Ascii("slea"), - ], - values: &[ - &["checkpoint"], - &["checker"], - &["checker"], - &["checkmate"], - &["checkpoint"], - &["checkpoints"], - &["checkpoints"], - &["checkpoints"], - &["checkpoints"], - &["cheetos"], - &["cheerleader"], - &["cheerleader"], - &["cheerleaders"], - &["cheerleader"], - &["cheerleaders"], - &["cheeseburger"], - &["cheeseburger"], - &["cheeseburgers"], - &["cheeseburger"], - &["cheeseburger"], - &["cheeseburgers"], - &["cheeseburger"], - &["cheeseburger"], - &["cheeseburgers"], - &["cheeseburger"], - &["cheeseburgers"], - &["cheesecake"], - &["cheesecake"], - &["cheeses"], - &["cheesecake"], - &["cheeses"], - &["cheeses"], - &["cheetos"], - &["cheeseburger"], - &["cheeseburgers"], - &["cheesecake"], - &["chief"], - &["chiefs"], - &["checker"], - &["checkmate"], - &["chelsea"], - &["chemical"], - &["chemically"], - &["chemistry"], - &["chemically"], - &["chemistry"], - &["chemistry"], - &["chernobyl"], - &["chernobyl"], - &["chernobyl"], - &["chernobyl"], - &["chernobyl"], - &["chernobyl"], - &["chelsea"], - ], - range: 2..=11, -}; - -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("ukles")], - values: &[&["chuckles"]], - range: 5..=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] = [ +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, - Some(&WORD_CHAI_NODE), - None, - None, - Some(&WORD_CHAL_NODE), - Some(&WORD_CHAM_NODE), - Some(&WORD_CHAN_NODE), - None, - None, - None, - Some(&WORD_CHAR_NODE), - Some(&WORD_CHAS_NODE), - Some(&WORD_CHAT_NODE), - None, None, None, None, @@ -78801,6 +149353,396 @@ static WORD_CHA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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("nboyl"), + dictgen::InsensitiveStr::Ascii("nobl"), + dictgen::InsensitiveStr::Ascii("nobly"), + dictgen::InsensitiveStr::Ascii("noybl"), + dictgen::InsensitiveStr::Ascii("nyobl"), + dictgen::InsensitiveStr::Ascii("onbyl"), + ], + values: &[ + &["chernobyl"], + &["chernobyl"], + &["chernobyl"], + &["chernobyl"], + &["chernobyl"], + &["chernobyl"], + ], + range: 4..=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("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"], + &["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("ots"), + 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: &[ + &["cheetos"], + &["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("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("kk"), + dictgen::InsensitiveStr::Ascii("kmeat"), + dictgen::InsensitiveStr::Ascii("koslovakia"), + 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("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("kum"), + dictgen::InsensitiveStr::Ascii("kums"), + dictgen::InsensitiveStr::Ascii("kuot"), + ], + values: &[ + &["check"], + &["checked"], + &["check", "czech"], + &["checkpoint"], + &["checkpoints"], + &["checked"], + &["checking"], + &["check"], + &["checkpoint"], + &["checks"], + &["checkaliases"], + &["checker"], + &["checksum"], + &["checked"], + &["checker"], + &["checks"], + &["check"], + &["checkmate"], + &["czechoslovakia"], + &["checkpoint"], + &["checkpoint"], + &["checkpoints"], + &["checkpoints"], + &["checkpoints"], + &["checkpoints"], + &["checksum"], + &["checksumming"], + &["checksumming"], + &["checksums"], + &["checksum"], + &["checksummed"], + &["checksumming"], + &["checksum"], + &["checksums"], + &["checkout"], + ], + 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, @@ -78808,13 +149750,28 @@ static WORD_CHAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("edral"), + dictgen::InsensitiveStr::Ascii("er"), dictgen::InsensitiveStr::Ascii("oic"), dictgen::InsensitiveStr::Ascii("olic"), dictgen::InsensitiveStr::Ascii("olics"), ], - values: &[&["cathedral"], &["chaotic"], &["catholic"], &["catholics"]], - range: 3..=5, + values: &[ + &["character"], + &["characters"], + &["catch"], + &["caught", "chatted"], + &["cathedral"], + &["chapter"], + &["chaotic"], + &["catholic"], + &["catholics"], + ], + range: 2..=6, }; static WORD_CHAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -78826,14 +149783,18 @@ pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("iers"), dictgen::InsensitiveStr::Ascii("iss"), + dictgen::InsensitiveStr::Ascii("nge"), dictgen::InsensitiveStr::Ascii("r"), dictgen::InsensitiveStr::Ascii("sids"), dictgen::InsensitiveStr::Ascii("sies"), + dictgen::InsensitiveStr::Ascii("sy"), ], values: &[ &["cashiers"], &["chassis"], - &["chaser"], + &["change", "changes"], + &["chaser", "chase"], + &["chassis"], &["chassis"], &["chassis"], ], @@ -78841,115 +149802,119 @@ pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_CHAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CHAR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CHAR_CHILDREN), value: None, }; -pub static WORD_CHAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("achter"), - dictgen::InsensitiveStr::Ascii("achters"), - dictgen::InsensitiveStr::Ascii("actaristic"), - dictgen::InsensitiveStr::Ascii("actaristics"), - dictgen::InsensitiveStr::Ascii("actarization"), - dictgen::InsensitiveStr::Ascii("actarize"), - dictgen::InsensitiveStr::Ascii("actarized"), - dictgen::InsensitiveStr::Ascii("acterazation"), - dictgen::InsensitiveStr::Ascii("actere"), - dictgen::InsensitiveStr::Ascii("acterisic"), - dictgen::InsensitiveStr::Ascii("acterisics"), - dictgen::InsensitiveStr::Ascii("acterisitc"), - dictgen::InsensitiveStr::Ascii("acterisitcs"), - dictgen::InsensitiveStr::Ascii("acterisitic"), - dictgen::InsensitiveStr::Ascii("acterisitics"), - dictgen::InsensitiveStr::Ascii("acteristc"), - dictgen::InsensitiveStr::Ascii("acteristcs"), - dictgen::InsensitiveStr::Ascii("acterists"), - dictgen::InsensitiveStr::Ascii("acteristsics"), - dictgen::InsensitiveStr::Ascii("acteritics"), - dictgen::InsensitiveStr::Ascii("acterizarion"), - dictgen::InsensitiveStr::Ascii("acterizaton"), - dictgen::InsensitiveStr::Ascii("actersistic"), - dictgen::InsensitiveStr::Ascii("actersitic"), - dictgen::InsensitiveStr::Ascii("actersitics"), - dictgen::InsensitiveStr::Ascii("acterz"), - dictgen::InsensitiveStr::Ascii("actor"), - dictgen::InsensitiveStr::Ascii("actoristics"), - dictgen::InsensitiveStr::Ascii("actors"), - dictgen::InsensitiveStr::Ascii("akters"), - dictgen::InsensitiveStr::Ascii("asmatic"), - dictgen::InsensitiveStr::Ascii("asteristic"), - dictgen::InsensitiveStr::Ascii("atable"), - dictgen::InsensitiveStr::Ascii("aterized"), - dictgen::InsensitiveStr::Ascii("caol"), - dictgen::InsensitiveStr::Ascii("col"), - dictgen::InsensitiveStr::Ascii("ecteristic"), - dictgen::InsensitiveStr::Ascii("ecteristics"), - dictgen::InsensitiveStr::Ascii("ecterization"), - dictgen::InsensitiveStr::Ascii("ecters"), - dictgen::InsensitiveStr::Ascii("gehr"), - dictgen::InsensitiveStr::Ascii("geur"), - dictgen::InsensitiveStr::Ascii("icterization"), - dictgen::InsensitiveStr::Ascii("icterized"), - dictgen::InsensitiveStr::Ascii("iman"), - dictgen::InsensitiveStr::Ascii("imastic"), - dictgen::InsensitiveStr::Ascii("imsa"), - dictgen::InsensitiveStr::Ascii("isa"), - dictgen::InsensitiveStr::Ascii("ismastic"), - dictgen::InsensitiveStr::Ascii("ismatisch"), - dictgen::InsensitiveStr::Ascii("istics"), - dictgen::InsensitiveStr::Ascii("itible"), - dictgen::InsensitiveStr::Ascii("misa"), - dictgen::InsensitiveStr::Ascii("ocal"), - dictgen::InsensitiveStr::Ascii("sima"), - dictgen::InsensitiveStr::Ascii("simatic"), - dictgen::InsensitiveStr::Ascii("tiable"), + 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"], - &["characters"], - &["characteristic"], - &["characteristics"], &["characterization"], - &["characterize"], &["characterized"], - &["characterization"], - &["characterize"], - &["characteristic"], - &["characteristics"], - &["characteristics"], - &["characteristics"], - &["characteristic"], - &["characteristics"], - &["characteristics"], - &["characteristics"], - &["characteristics"], - &["characteristic"], - &["characteristic"], - &["characterization"], - &["characterization"], - &["characteristic"], - &["characteristics"], - &["characteristics"], - &["characterize"], + &["characters"], &["character"], - &["characteristics"], &["characters"], - &["characters"], - &["charismatic"], - &["characteristics"], - &["charitable"], - &["characterized"], - &["charcoal"], - &["charcoal"], - &["characteristic"], - &["characteristics"], - &["characterization"], - &["characters"], - &["charger"], - &["charger"], - &["characterization"], - &["characterized"], &["chairman"], &["charismatic"], &["charisma"], @@ -78959,12 +149924,552 @@ pub static WORD_CHAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["characteristics"], &["charitable"], &["charisma"], - &["charcoal"], - &["charisma"], - &["charismatic"], - &["charitable"], ], - range: 3..=12, + 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("ol"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("ters"), + dictgen::InsensitiveStr::Ascii("tor"), + dictgen::InsensitiveStr::Ascii("tors"), + ], + values: &[ + &["charcoal"], + &["character"], + &["charcoal"], + &["character"], + &["characters"], + &["character"], + &["characters"], + ], + range: 2..=4, +}; + +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("cters"), + dictgen::InsensitiveStr::Ascii("matic"), + dictgen::InsensitiveStr::Ascii("teristic"), + ], + values: &[&["characters"], &["charismatic"], &["characteristics"]], + range: 5..=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("cter"), + ], + values: &[&["character"], &["character"]], + range: 4..=5, +}; + +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), + None, + 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_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("ritics"), + 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"], + &["characterization"], + &["characterization"], + &["characteristic"], + &["characteristically"], + &["characteristics"], + &["characteristics"], + &["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("ters")], + values: &[&["characters"]], + range: 4..=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 { @@ -78974,30 +150479,86 @@ static WORD_CHAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_CHAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("dlure"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("eged"), + dictgen::InsensitiveStr::Ascii("el"), + dictgen::InsensitiveStr::Ascii("ell"), + dictgen::InsensitiveStr::Ascii("els"), dictgen::InsensitiveStr::Ascii("gable"), + dictgen::InsensitiveStr::Ascii("geing"), + dictgen::InsensitiveStr::Ascii("gged"), + 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("ne"), + dictgen::InsensitiveStr::Ascii("neles"), + dictgen::InsensitiveStr::Ascii("nes"), + 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: &[ + &["canceled"], + &["canceling"], &["chancellor"], &["chancellor"], + &["changed"], &["chancellor"], + &["channel", "cancel"], &["chandler"], + &["change", "chain"], + &["changed", "chained"], + &["changed"], + &["channel"], + &["channel"], + &["channels"], &["changeable"], + &["changing"], + &["changed"], + &["changelog"], + &["changing"], + &["chained"], + &["chaining", "changing"], + &["changing"], &["chainsaw"], &["chandler"], + &["challenge"], + &["challenging"], + &["channel"], + &["channels"], + &["channels", "chances", "changes"], + &["channel"], + &["channel"], + &["channels"], + &["channel"], + &["channels"], &["championship"], &["championships"], &["chancellor"], + &["chances"], ], - range: 4..=9, + range: 1..=9, }; static WORD_CHAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79061,6 +150622,7 @@ static WORD_CHAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -79082,6 +150644,7 @@ pub static WORD_CHAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["challenging"], &["challenge"], + &["challenge"], &["challenged"], &["challenges"], &["challenging"], @@ -79109,11 +150672,119 @@ static WORD_CHAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["chairman"], &["charitable"]], - range: 5..=6, + 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")], + values: &[&["changed"]], + range: 3..=3, +}; + +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("he"), + dictgen::InsensitiveStr::Ascii("hed"), + dictgen::InsensitiveStr::Ascii("heline"), + ], + values: &[ + &["character"], + &["characters"], + &["cache"], + &["cached"], + &["cacheline"], + ], + range: 2..=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("rges")], + values: &[&["charges"]], + range: 4..=4, +}; + +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 { @@ -79124,12 +150795,12 @@ static WORD_CE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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, - None, - None, - None, + Some(&WORD_CEH_NODE), None, None, None, @@ -79156,9 +150827,13 @@ static WORD_CET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_CET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lics")], - values: &[&["celtics"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("lics"), + dictgen::InsensitiveStr::Ascii("rainly"), + dictgen::InsensitiveStr::Ascii("ting"), + ], + values: &[&["celtics"], &["certainly"], &["setting"]], + range: 4..=6, }; static WORD_CES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79183,82 +150858,383 @@ pub static WORD_CES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_CER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CER_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CER_CHILDREN), value: None, }; -pub static WORD_CER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + Some(&WORD_CERO_NODE), + None, + None, + None, + 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: None, +}; + +pub static WORD_CERTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("atine"), - dictgen::InsensitiveStr::Ascii("beral"), - dictgen::InsensitiveStr::Ascii("breus"), - dictgen::InsensitiveStr::Ascii("bures"), - dictgen::InsensitiveStr::Ascii("cumstance"), - dictgen::InsensitiveStr::Ascii("ebrawl"), - dictgen::InsensitiveStr::Ascii("emone"), - dictgen::InsensitiveStr::Ascii("emonias"), - dictgen::InsensitiveStr::Ascii("emoniis"), - dictgen::InsensitiveStr::Ascii("emonije"), - dictgen::InsensitiveStr::Ascii("ification"), - dictgen::InsensitiveStr::Ascii("imonial"), - dictgen::InsensitiveStr::Ascii("imonies"), - dictgen::InsensitiveStr::Ascii("imonious"), - dictgen::InsensitiveStr::Ascii("imony"), - dictgen::InsensitiveStr::Ascii("itfication"), - dictgen::InsensitiveStr::Ascii("maic"), - dictgen::InsensitiveStr::Ascii("omony"), - dictgen::InsensitiveStr::Ascii("tainity"), - dictgen::InsensitiveStr::Ascii("tainlyt"), - dictgen::InsensitiveStr::Ascii("taintity"), - dictgen::InsensitiveStr::Ascii("tainy"), - dictgen::InsensitiveStr::Ascii("tanity"), - dictgen::InsensitiveStr::Ascii("tian"), - dictgen::InsensitiveStr::Ascii("tianty"), - dictgen::InsensitiveStr::Ascii("tificaat"), - dictgen::InsensitiveStr::Ascii("tificaiton"), - dictgen::InsensitiveStr::Ascii("tificare"), - dictgen::InsensitiveStr::Ascii("tificationkits"), - dictgen::InsensitiveStr::Ascii("tificato"), - dictgen::InsensitiveStr::Ascii("tificats"), - dictgen::InsensitiveStr::Ascii("tificiate"), - dictgen::InsensitiveStr::Ascii("vial"), + 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("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("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("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: &[ - &["creatine"], - &["cerebral"], - &["cerberus"], - &["cerberus"], - &["circumstance"], - &["cerebral"], - &["ceremonies"], - &["ceremonies"], - &["ceremonies"], - &["ceremonies"], - &["verification"], - &["ceremonial"], - &["ceremonies"], - &["ceremonious"], - &["ceremony"], + &["certain"], + &["certainly"], + &["certainty"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certification"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certification"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certification"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certification"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certificating"], + &["certification"], &["certifications"], - &["ceramic"], - &["ceremony"], - &["certainty"], - &["certainty"], + &["certificate"], + &["certification"], + &["certificate"], + &["certificate"], + &["certificated"], + &["certificating", "certification"], + &["certifications"], + &["certification"], + &["certification"], + &["certificates"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certificate"], + &["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("iny"), + dictgen::InsensitiveStr::Ascii("ion"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("nity"), + ], + values: &[ + &["certainly"], &["certainty"], &["certainty"], &["certainty"], &["certain"], &["certainty"], - &["certificate"], - &["certification"], - &["certificate"], - &["certifications"], - &["certification"], - &["certificates"], - &["certificate"], - &["cervical"], + &["certainty"], + &["certain"], + &["certain"], + &["certainty"], ], - range: 4..=14, + range: 1..=6, +}; + +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_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")], + values: &[&["ceramic"]], + range: 3..=3, +}; + +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("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("tfication"), + ], + values: &[ + &["verification", "certification"], + &["certifications", "verifications"], + &["certified", "verified"], + &["certifies", "verifies"], + &["certify", "verify"], + &["certifying", "verifying"], + &["ceremonial"], + &["ceremonies"], + &["ceremonious"], + &["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("umstance")], + values: &[&["circumstance"]], + range: 8..=8, +}; + +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("te"), + dictgen::InsensitiveStr::Ascii("tine"), + ], + values: &[&["create"], &["creatine"]], + range: 2..=4, }; static WORD_CEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79268,44 +151244,66 @@ static WORD_CEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_CEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ario"), + dictgen::InsensitiveStr::Ascii("arios"), + dictgen::InsensitiveStr::Ascii("cter"), dictgen::InsensitiveStr::Ascii("cus"), + dictgen::InsensitiveStr::Ascii("gter"), dictgen::InsensitiveStr::Ascii("itpede"), + dictgen::InsensitiveStr::Ascii("sequence"), dictgen::InsensitiveStr::Ascii("sorhsip"), dictgen::InsensitiveStr::Ascii("sur"), dictgen::InsensitiveStr::Ascii("surship"), + dictgen::InsensitiveStr::Ascii("tain"), dictgen::InsensitiveStr::Ascii("tentenial"), dictgen::InsensitiveStr::Ascii("tepide"), + dictgen::InsensitiveStr::Ascii("terd"), dictgen::InsensitiveStr::Ascii("teres"), 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("trase"), + dictgen::InsensitiveStr::Ascii("trifugeable"), + dictgen::InsensitiveStr::Ascii("trigrade"), dictgen::InsensitiveStr::Ascii("truies"), dictgen::InsensitiveStr::Ascii("truy"), dictgen::InsensitiveStr::Ascii("tuties"), dictgen::InsensitiveStr::Ascii("tuty"), ], values: &[ + &["scenario"], + &["scenarios"], + &["center"], &["census"], + &["center"], &["centipede"], + &["consequence"], &["censorship"], - &["censor"], + &["censor", "censure"], &["censorship"], + &["certain"], &["centennial"], &["centipede"], + &["centered"], &["centers"], &["centers"], &["centipede"], &["centipede"], &["centipede"], + &["centisecond"], + &["centiseconds"], &["centres"], + &["centrifugable"], + &["centigrade"], &["centuries"], &["century"], &["centuries"], &["century"], ], - range: 3..=9, + range: 3..=11, }; static WORD_CEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79352,9 +151350,12 @@ pub static WORD_CEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ibrations"), dictgen::InsensitiveStr::Ascii("isus"), dictgen::InsensitiveStr::Ascii("itcs"), + 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"), @@ -79381,14 +151382,77 @@ pub static WORD_CEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["celebrations"], &["celsius"], &["celtics"], + &["cells"], &["cellpadding"], + &["cells"], &["cellular"], &["cellular"], + &["cells"], &["celsius"], &["cellular"], &["cleverly"], ], - range: 4..=12, + 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 { @@ -79397,9 +151461,75 @@ static WORD_CEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_CEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("sar")], - values: &[&["cesar"]], - range: 3..=3, + keys: &[ + dictgen::InsensitiveStr::Ascii("rtype"), + dictgen::InsensitiveStr::Ascii("sar"), + dictgen::InsensitiveStr::Ascii("te"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("tes"), + dictgen::InsensitiveStr::Ascii("ting"), + dictgen::InsensitiveStr::Ascii("tion"), + ], + values: &[ + &["cleartype"], + &["cesar", "cesar"], + &["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("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"), + ], + values: &[ + &["cache"], + &["scale"], + &["certificate"], + &["certificated"], + &["certificates"], + &["certification"], + &["accessible"], + &["cache"], + &["configuration"], + &["coordinate"], + &["coordinates"], + &["coordinates"], + &["accountant"], + ], + range: 2..=12, }; static WORD_CA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79411,8 +151541,8 @@ static WORD_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_CAB_NODE), Some(&WORD_CAC_NODE), - None, - None, + Some(&WORD_CAD_NODE), + Some(&WORD_CAE_NODE), Some(&WORD_CAF_NODE), None, Some(&WORD_CAH_NODE), @@ -79443,11 +151573,13 @@ static WORD_CAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), ], - values: &[&["cavalry"], &["cavalry"]], - range: 4..=4, + values: &[&["caveat"], &["caveats"], &["cavalry"], &["cavalry"]], + range: 3..=4, }; static WORD_CAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79460,29 +151592,49 @@ pub static WORD_CAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tionsly"), ], values: &[ &["caucasian"], &["caucasian"], &["caucasian"], + &["caucasian"], + &["caught"], + &["caught"], + &["caught"], &["cauliflower"], + &["causing"], &["cauliflower"], &["canucks"], &["caucasian"], &["causality"], &["casualties"], &["casualty"], + &["causes"], + &["caution"], + &["cautioned"], + &["cautions"], + &["cautious"], &["cautiously"], ], - range: 4..=8, + range: 2..=8, }; static WORD_CAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79493,11 +151645,11 @@ static WORD_CAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_CATA_NODE), None, - None, + Some(&WORD_CATC_NODE), None, Some(&WORD_CATE_NODE), None, - None, + Some(&WORD_CATG_NODE), Some(&WORD_CATH_NODE), Some(&WORD_CATI_NODE), None, @@ -79506,7 +151658,7 @@ static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, Some(&WORD_CATO_NODE), - None, + Some(&WORD_CATP_NODE), None, None, None, @@ -79542,6 +151694,21 @@ pub static WORD_CATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), + ], + values: &[&["capture"], &["capture"], &["captured"]], + range: 3..=4, +}; + static WORD_CATO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CATO_CHILDREN), value: None, @@ -79550,11 +151717,17 @@ static WORD_CATO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["catastrophic"], &["catastrophic"]], - range: 7..=8, + values: &[ + &["categorized"], + &["factory"], + &["catastrophic"], + &["catastrophic"], + ], + range: 2..=8, }; static WORD_CATL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79630,6 +151803,27 @@ pub static WORD_CATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -79637,13 +151831,22 @@ static WORD_CATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"), @@ -79656,13 +151859,22 @@ pub static WORD_CATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("strophic"), ], values: &[ + &["categorical"], + &["categorically"], + &["categories"], + &["category"], &["categorically"], &["categorize"], + &["category", "categories"], &["categorized"], &["categorize"], &["categorized"], &["categorized"], + &["categorical"], + &["categorically"], + &["categories"], &["categorized"], + &["category"], &["caterpillar"], &["caterpillars"], &["categorize"], @@ -79674,7 +151886,23 @@ pub static WORD_CATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["caterpillars"], &["catastrophic"], ], - range: 6..=8, + range: 4..=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("hs"), + ], + values: &[&["catch"], &["caught"], &["catch"], &["catches"]], + range: 2..=3, }; static WORD_CATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79692,6 +151920,7 @@ pub static WORD_CATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("cylsm"), dictgen::InsensitiveStr::Ascii("cyslm"), dictgen::InsensitiveStr::Ascii("gorically"), + dictgen::InsensitiveStr::Ascii("gorie"), dictgen::InsensitiveStr::Ascii("gories"), dictgen::InsensitiveStr::Ascii("gorized"), dictgen::InsensitiveStr::Ascii("gory"), @@ -79709,12 +151938,15 @@ pub static WORD_CATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("straphic"), 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: &[ @@ -79726,12 +151958,13 @@ pub static WORD_CATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["cataclysm"], &["cataclysm"], &["categorically"], + &["category", "categories"], &["categories"], &["categorized"], &["category"], &["cataclysm"], &["catalogue"], - &["catiline"], + &["catiline", "catalina"], &["catalogue"], &["catalyst"], &["caterpillar"], @@ -79743,15 +151976,18 @@ pub static WORD_CATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["catastrophic"], &["catastrophe"], &["catastrophic"], + &["catastrophic"], &["catastrophe"], &["catastrophe"], &["catastrophe"], &["catastrophe"], &["catastrophic"], + &["catastrophically"], &["catastrophe"], + &["catastrophic"], &["catalyst"], ], - range: 4..=9, + range: 4..=11, }; static WORD_CAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -79764,7 +152000,10 @@ pub static WORD_CAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("aulity"), dictgen::InsensitiveStr::Ascii("aulties"), dictgen::InsensitiveStr::Ascii("aulty"), + dictgen::InsensitiveStr::Ascii("cace"), + dictgen::InsensitiveStr::Ascii("elessely"), dictgen::InsensitiveStr::Ascii("ette"), + dictgen::InsensitiveStr::Ascii("he"), dictgen::InsensitiveStr::Ascii("heir"), dictgen::InsensitiveStr::Ascii("heirs"), dictgen::InsensitiveStr::Ascii("hieer"), @@ -79797,7 +152036,10 @@ pub static WORD_CAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["causality"], &["casualties"], &["casualty"], + &["cascade"], + &["caselessly"], &["cassette"], + &["cache"], &["cashier"], &["cashiers"], &["cashier"], @@ -79840,7 +152082,7 @@ static WORD_CAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_CARC_NODE), Some(&WORD_CARD_NODE), Some(&WORD_CARE_NODE), - None, + Some(&WORD_CARF_NODE), None, None, Some(&WORD_CARI_NODE), @@ -79869,9 +152111,12 @@ static WORD_CARY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_CARY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ons")], - values: &[&["crayons"]], - range: 3..=3, + 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 { @@ -79898,6 +152143,7 @@ pub static WORD_CART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ells"), dictgen::InsensitiveStr::Ascii("hagian"), dictgen::InsensitiveStr::Ascii("hographer"), + dictgen::InsensitiveStr::Ascii("iesian"), dictgen::InsensitiveStr::Ascii("ilege"), dictgen::InsensitiveStr::Ascii("ilidge"), dictgen::InsensitiveStr::Ascii("irdge"), @@ -79919,6 +152165,7 @@ pub static WORD_CART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["cartels"], &["carthaginian"], &["cartographer"], + &["cartesian"], &["cartilage"], &["cartilage"], &["cartridge"], @@ -79944,19 +152191,35 @@ static WORD_CARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_CARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("eer"), + dictgen::InsensitiveStr::Ascii("eid"), dictgen::InsensitiveStr::Ascii("ers"), + 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: &[ &["career"], + &["carried"], &["careers"], + &["carriage"], &["caribbean"], &["caribbean"], + &["carriage", "cartridge"], + &["carrier"], + &["carriage"], &["carrots"], &["carrots"], + &["carrier"], + &["carrying"], + &["carrying"], ], range: 3..=6, }; @@ -80007,8 +152270,8 @@ pub static WORD_CARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic values: &[ &["carnegie"], &["cranberry"], - &["carnage"], - &["carnage"], + &["carnage", "carnegie"], + &["carnage", "carnegie"], &["carnegie"], &["carnivorous"], &["carnival"], @@ -80050,6 +152313,7 @@ pub static WORD_CARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("acture"), dictgen::InsensitiveStr::Ascii("actures"), + dictgen::InsensitiveStr::Ascii("age"), dictgen::InsensitiveStr::Ascii("cate"), dictgen::InsensitiveStr::Ascii("catore"), dictgen::InsensitiveStr::Ascii("caturale"), @@ -80060,15 +152324,18 @@ pub static WORD_CARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("nval"), dictgen::InsensitiveStr::Ascii("smatic"), ], values: &[ &["caricature"], &["caricature"], + &["carriage"], &["caricature"], &["caricature"], &["caricature"], @@ -80079,15 +152346,28 @@ pub static WORD_CARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["caricature"], &["cardiac"], &["cardigan"], + &["carriage"], &["cardinal"], &["cardinals"], &["cardiovascular"], + &["carrier"], &["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, @@ -80103,7 +152383,7 @@ pub static WORD_CARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["carefully"], - &["careful"], + &["careful", "carefully"], &["carefully"], &["carefully"], &["caring"], @@ -80168,7 +152448,7 @@ pub static WORD_CARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("as"), dictgen::InsensitiveStr::Ascii("iature"), ], - values: &[&["carcass"], &["caricature"]], + values: &[&["carcass", "caracas"], &["caricature"]], range: 2..=6, }; @@ -80186,6 +152466,7 @@ pub static WORD_CARB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ohyrdate"), dictgen::InsensitiveStr::Ascii("ohyrdates"), dictgen::InsensitiveStr::Ascii("oyhdrates"), + dictgen::InsensitiveStr::Ascii("us"), ], values: &[ &["carbine"], @@ -80195,8 +152476,9 @@ pub static WORD_CARB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["carbohydrates"], &["carbohydrates"], &["carbohydrates"], + &["cardbus"], ], - range: 3..=9, + range: 2..=9, }; static WORD_CARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80208,16 +152490,24 @@ pub static WORD_CARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("chter"), dictgen::InsensitiveStr::Ascii("citure"), + dictgen::InsensitiveStr::Ascii("cter"), + dictgen::InsensitiveStr::Ascii("ctere"), + dictgen::InsensitiveStr::Ascii("cteristic"), dictgen::InsensitiveStr::Ascii("cterized"), + dictgen::InsensitiveStr::Ascii("cters"), dictgen::InsensitiveStr::Ascii("nge"), ], values: &[ &["character"], &["caricature"], + &["character"], + &["character"], + &["characteristic"], &["characterized"], + &["characters"], &["carnage"], ], - range: 3..=8, + range: 3..=9, }; static WORD_CAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80227,7 +152517,7 @@ static WORD_CAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_CAPA_NODE), - None, + Some(&WORD_CAPB_NODE), None, None, Some(&WORD_CAPE_NODE), @@ -80241,7 +152531,7 @@ static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_CAPM_NODE), None, None, - None, + Some(&WORD_CAPP_NODE), None, Some(&WORD_CAPR_NODE), Some(&WORD_CAPS_NODE), @@ -80263,9 +152553,17 @@ pub static WORD_CAPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("sle"), dictgen::InsensitiveStr::Ascii("sles"), + dictgen::InsensitiveStr::Ascii("tre"), dictgen::InsensitiveStr::Ascii("tres"), + dictgen::InsensitiveStr::Ascii("ture"), + ], + values: &[ + &["capsule"], + &["capsules"], + &["capture"], + &["captures"], + &["capture"], ], - values: &[&["capsule"], &["capsules"], &["captures"]], range: 3..=4, }; @@ -80276,6 +152574,7 @@ static WORD_CAPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("eurs"), @@ -80290,10 +152589,12 @@ pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ians"), dictgen::InsensitiveStr::Ascii("iol"), dictgen::InsensitiveStr::Ascii("ivitiy"), + dictgen::InsensitiveStr::Ascii("rure"), dictgen::InsensitiveStr::Ascii("ued"), dictgen::InsensitiveStr::Ascii("urd"), ], values: &[ + &["capable"], &["captains"], &["captains"], &["captures"], @@ -80308,6 +152609,7 @@ pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["captains"], &["capitol"], &["captivity"], + &["capture"], &["captured"], &["captured"], ], @@ -80350,6 +152652,17 @@ pub static WORD_CAPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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, @@ -80369,6 +152682,7 @@ static WORD_CAPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("alized"), + dictgen::InsensitiveStr::Ascii("bilities"), dictgen::InsensitiveStr::Ascii("ble"), dictgen::InsensitiveStr::Ascii("cator"), dictgen::InsensitiveStr::Ascii("cators"), @@ -80406,6 +152720,7 @@ pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic ], values: &[ &["capitalized"], + &["capabilities"], &["capable"], &["capacitor"], &["capacitors"], @@ -80450,9 +152765,26 @@ static WORD_CAPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_CAPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rbility")], - values: &[&["capability"]], - range: 7..=7, + 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 { @@ -80462,18 +152794,39 @@ static WORD_CAPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"), @@ -80482,18 +152835,39 @@ pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], @@ -80501,7 +152875,7 @@ pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["capitalize"], &["capitalized"], ], - range: 5..=10, + range: 3..=10, }; static WORD_CAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80516,88 +152890,134 @@ pub static WORD_CAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_CAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_CAN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_CAN_CHILDREN), value: None, }; -pub static WORD_CAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_CAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_CANA_NODE), + None, + Some(&WORD_CANC_NODE), + Some(&WORD_CAND_NODE), + None, + 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), + None, + None, + Some(&WORD_CANV_NODE), + None, + None, + None, + None, +]; + +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_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("adains"), - dictgen::InsensitiveStr::Ascii("adianese"), - dictgen::InsensitiveStr::Ascii("adias"), - dictgen::InsensitiveStr::Ascii("anbis"), - dictgen::InsensitiveStr::Ascii("celas"), - dictgen::InsensitiveStr::Ascii("celes"), - dictgen::InsensitiveStr::Ascii("cellato"), - dictgen::InsensitiveStr::Ascii("cells"), - dictgen::InsensitiveStr::Ascii("celtation"), - dictgen::InsensitiveStr::Ascii("ceres"), - dictgen::InsensitiveStr::Ascii("cerns"), - dictgen::InsensitiveStr::Ascii("cerus"), - dictgen::InsensitiveStr::Ascii("cles"), - dictgen::InsensitiveStr::Ascii("cres"), - dictgen::InsensitiveStr::Ascii("cuks"), - dictgen::InsensitiveStr::Ascii("dadate"), - dictgen::InsensitiveStr::Ascii("diate"), - dictgen::InsensitiveStr::Ascii("didatas"), - dictgen::InsensitiveStr::Ascii("didats"), - dictgen::InsensitiveStr::Ascii("didatxs"), - dictgen::InsensitiveStr::Ascii("didiate"), - dictgen::InsensitiveStr::Ascii("diens"), - dictgen::InsensitiveStr::Ascii("ditates"), - dictgen::InsensitiveStr::Ascii("ides"), - dictgen::InsensitiveStr::Ascii("istre"), - dictgen::InsensitiveStr::Ascii("nabil"), - dictgen::InsensitiveStr::Ascii("nabilism"), - dictgen::InsensitiveStr::Ascii("nabolism"), - dictgen::InsensitiveStr::Ascii("nbial"), - dictgen::InsensitiveStr::Ascii("niablism"), - dictgen::InsensitiveStr::Ascii("nibalisim"), - dictgen::InsensitiveStr::Ascii("nibalizm"), - dictgen::InsensitiveStr::Ascii("nibaljim"), - dictgen::InsensitiveStr::Ascii("niballism"), - dictgen::InsensitiveStr::Ascii("nibalsim"), - dictgen::InsensitiveStr::Ascii("nibalsm"), - dictgen::InsensitiveStr::Ascii("nibas"), - dictgen::InsensitiveStr::Ascii("nibilism"), - dictgen::InsensitiveStr::Ascii("nister"), - dictgen::InsensitiveStr::Ascii("nisters"), - dictgen::InsensitiveStr::Ascii("nnot"), - dictgen::InsensitiveStr::Ascii("nobalism"), - dictgen::InsensitiveStr::Ascii("noical"), - dictgen::InsensitiveStr::Ascii("nonical"), - dictgen::InsensitiveStr::Ascii("notation"), - dictgen::InsensitiveStr::Ascii("notations"), - dictgen::InsensitiveStr::Ascii("oncial"), - dictgen::InsensitiveStr::Ascii("rage"), - dictgen::InsensitiveStr::Ascii("siter"), + dictgen::InsensitiveStr::Ascii("nalize"), + dictgen::InsensitiveStr::Ascii("nalized"), + dictgen::InsensitiveStr::Ascii("nalizes"), + dictgen::InsensitiveStr::Ascii("nalizing"), + dictgen::InsensitiveStr::Ascii("ncial"), + dictgen::InsensitiveStr::Ascii("nicalizations"), + dictgen::InsensitiveStr::Ascii("nival"), + dictgen::InsensitiveStr::Ascii("t"), + ], + values: &[ + &["canonicalize"], + &["canonicalized"], + &["canonicalizes"], + &["canonicalizing"], + &["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("abilism"), + 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("onicalize"), + dictgen::InsensitiveStr::Ascii("otation"), + dictgen::InsensitiveStr::Ascii("otations"), + dictgen::InsensitiveStr::Ascii("ott"), ], values: &[ - &["canadians"], - &["canadians"], - &["canadians"], - &["cannabis"], - &["cancels"], - &["cancels"], - &["cancellation"], - &["cancels"], - &["cancellation"], - &["cancers"], - &["cancers"], - &["cancers"], - &["cancels"], - &["cancers"], - &["canucks"], - &["candidate"], - &["candidate"], - &["candidates"], - &["candidates"], - &["candidates"], - &["candidate"], - &["candies"], - &["candidates"], - &["candies"], - &["canister"], &["cannibal"], &["cannibalism"], &["cannibalism"], @@ -80615,15 +153035,158 @@ pub static WORD_CAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["canisters"], &["cannot"], &["cannibalism"], + &["cannot"], &["canonical"], &["canonical"], + &["canonicalize"], &["connotation"], &["connotations"], - &["canonical"], - &["carnage"], - &["canister"], + &["cannot"], ], - range: 4..=9, + range: 3..=9, +}; + +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"), + ], + values: &[&["change"], &["changed"]], + 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("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("itates"), + ], + values: &[ + &["candidate"], + &["candidates"], + &["candidate"], + &["candidates"], + &["candidates"], + &["candidates"], + &["candidates"], + &["candidate"], + &["candidates"], + &["candies"], + &["candidate"], + &["candidates"], + &["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("eles"), + 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"], + &["cancels"], + &["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("dains"), + dictgen::InsensitiveStr::Ascii("dan"), + dictgen::InsensitiveStr::Ascii("dianese"), + dictgen::InsensitiveStr::Ascii("dias"), + dictgen::InsensitiveStr::Ascii("nbis"), + ], + values: &[ + &["canadians"], + &["canadian"], + &["canadians"], + &["canadians"], + &["cannabis"], + ], + range: 3..=7, }; static WORD_CAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80645,6 +153208,7 @@ pub static WORD_CAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("brigde"), dictgen::InsensitiveStr::Ascii("brige"), dictgen::InsensitiveStr::Ascii("oflage"), + dictgen::InsensitiveStr::Ascii("oflague"), dictgen::InsensitiveStr::Ascii("ofluage"), dictgen::InsensitiveStr::Ascii("oufalge"), dictgen::InsensitiveStr::Ascii("ouflague"), @@ -80662,6 +153226,7 @@ pub static WORD_CAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -80689,6 +153254,7 @@ pub static WORD_CAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["camouflage"], &["camouflage"], &["camouflage"], + &["camouflage"], &["campaign"], &["campaigning"], &["campaigns"], @@ -80699,6 +153265,7 @@ pub static WORD_CAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["campaigning"], &["campaigns"], &["campaigns"], + &["comparing"], &["campers"], &["campers"], &["campaigns"], @@ -80719,14 +153286,14 @@ static WORD_CAL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_CALB_NODE), Some(&WORD_CALC_NODE), None, - None, + Some(&WORD_CALE_NODE), None, Some(&WORD_CALG_NODE), None, Some(&WORD_CALI_NODE), None, None, - None, + Some(&WORD_CALL_NODE), None, None, Some(&WORD_CALO_NODE), @@ -80761,8 +153328,11 @@ static WORD_CALU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_CALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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"), @@ -80770,15 +153340,23 @@ pub static WORD_CALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("clators"), dictgen::InsensitiveStr::Ascii("culate"), dictgen::InsensitiveStr::Ascii("culated"), + 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("ses"), ], values: &[ + &["calculate"], &["calculate"], &["calculated"], + &["calculator"], + &["calculates"], &["calculating"], &["calculation"], &["calculations"], @@ -80786,13 +153364,18 @@ pub static WORD_CALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["calculators"], &["calculate"], &["calculated"], + &["value"], &["cauliflower"], &["calculate"], &["calculated"], &["calculator"], + &["calculates"], + &["calculating"], + &["calculation"], + &["calculations"], &["clauses"], ], - range: 3..=8, + range: 1..=8, }; static WORD_CALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80802,12 +153385,20 @@ static WORD_CALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: &[&["classification"], &["classified"], &["classify"]], - range: 4..=10, + values: &[ + &["calls", "class"], + &["classes"], + &["classification"], + &["classified"], + &["classify"], + ], + range: 1..=10, }; static WORD_CALR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80846,6 +153437,67 @@ pub static WORD_CALO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("ibrated"), + dictgen::InsensitiveStr::Ascii("ibration"), + dictgen::InsensitiveStr::Ascii("ibri"), + dictgen::InsensitiveStr::Ascii("ig"), + dictgen::InsensitiveStr::Ascii("int"), + dictgen::InsensitiveStr::Ascii("led"), + dictgen::InsensitiveStr::Ascii("lee"), + dictgen::InsensitiveStr::Ascii("oed"), + dictgen::InsensitiveStr::Ascii("sr"), + ], + values: &[ + &["callback"], + &["callbacks"], + &["callback"], + &["callback"], + &["callback"], + &["callback"], + &["callback"], + &["callbacks"], + &["callback"], + &["callback"], + &["callchain"], + &["called"], + &["called"], + &["called"], + &["calls"], + &["calibrated"], + &["calibration"], + &["calibri"], + &["calling"], + &["calling"], + &["called"], + &["callee"], + &["called"], + &["calls"], + ], + range: 1..=8, +}; + static WORD_CALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CALI_CHILDREN), value: None, @@ -80853,11 +153505,14 @@ static WORD_CALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("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"), @@ -80879,14 +153534,20 @@ pub static WORD_CALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], &["calibration"], &["calibration"], + &["calibrate"], + &["calibration"], &["calcium"], &["californian"], &["californian"], @@ -80908,9 +153569,12 @@ pub static WORD_CALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["california"], &["californian"], &["calligraphy"], + &["calling"], + &["claiming"], + &["calling", "scaling", "culling"], &["californian"], ], - range: 3..=9, + range: 2..=9, }; static WORD_CALG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -80924,6 +153588,21 @@ pub static WORD_CALG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic range: 4..=4, }; +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("ed"), + dictgen::InsensitiveStr::Ascii("r"), + dictgen::InsensitiveStr::Ascii("scing"), + ], + values: &[&["called"], &["caller"], &["coalescing"]], + range: 1..=5, +}; + static WORD_CALC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_CALC_CHILDREN), value: None, @@ -80931,19 +153610,34 @@ static WORD_CALC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_CALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("able"), + dictgen::InsensitiveStr::Ascii("alate"), + dictgen::InsensitiveStr::Ascii("iulate"), + dictgen::InsensitiveStr::Ascii("iulating"), + dictgen::InsensitiveStr::Ascii("lation"), + dictgen::InsensitiveStr::Ascii("luate"), + dictgen::InsensitiveStr::Ascii("luated"), + dictgen::InsensitiveStr::Ascii("luates"), dictgen::InsensitiveStr::Ascii("luations"), dictgen::InsensitiveStr::Ascii("luator"), + dictgen::InsensitiveStr::Ascii("ualation"), dictgen::InsensitiveStr::Ascii("ualte"), dictgen::InsensitiveStr::Ascii("ualted"), + dictgen::InsensitiveStr::Ascii("ualter"), + dictgen::InsensitiveStr::Ascii("ualtes"), dictgen::InsensitiveStr::Ascii("ualting"), dictgen::InsensitiveStr::Ascii("ualtion"), dictgen::InsensitiveStr::Ascii("ualtions"), dictgen::InsensitiveStr::Ascii("ualtor"), dictgen::InsensitiveStr::Ascii("ualtors"), + dictgen::InsensitiveStr::Ascii("uate"), + dictgen::InsensitiveStr::Ascii("uations"), dictgen::InsensitiveStr::Ascii("uim"), dictgen::InsensitiveStr::Ascii("ulador"), + dictgen::InsensitiveStr::Ascii("ulaion"), dictgen::InsensitiveStr::Ascii("ular"), dictgen::InsensitiveStr::Ascii("ularon"), + dictgen::InsensitiveStr::Ascii("ulatble"), dictgen::InsensitiveStr::Ascii("ulater"), dictgen::InsensitiveStr::Ascii("ulaters"), dictgen::InsensitiveStr::Ascii("ulatin"), @@ -80951,22 +153645,55 @@ pub static WORD_CALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ulatios"), dictgen::InsensitiveStr::Ascii("ulatoare"), dictgen::InsensitiveStr::Ascii("ulatons"), + dictgen::InsensitiveStr::Ascii("ulatted"), + dictgen::InsensitiveStr::Ascii("ulatter"), + dictgen::InsensitiveStr::Ascii("ulattion"), + dictgen::InsensitiveStr::Ascii("ulattions"), + dictgen::InsensitiveStr::Ascii("ulaution"), + dictgen::InsensitiveStr::Ascii("ulautions"), + dictgen::InsensitiveStr::Ascii("ulcate"), + dictgen::InsensitiveStr::Ascii("ulcation"), + dictgen::InsensitiveStr::Ascii("uled"), dictgen::InsensitiveStr::Ascii("uls"), + dictgen::InsensitiveStr::Ascii("ultate"), + dictgen::InsensitiveStr::Ascii("ultated"), + dictgen::InsensitiveStr::Ascii("ultater"), + dictgen::InsensitiveStr::Ascii("ultating"), + dictgen::InsensitiveStr::Ascii("ultator"), + dictgen::InsensitiveStr::Ascii("ulting"), + dictgen::InsensitiveStr::Ascii("uluations"), + dictgen::InsensitiveStr::Ascii("urate"), + dictgen::InsensitiveStr::Ascii("utated"), ], values: &[ + &["calculable"], + &["calculate"], + &["calculate"], + &["calculating"], &["calculation"], - &["calculators"], &["calculate"], &["calculated"], + &["calculates"], + &["calculation"], + &["calculators"], + &["calculation"], + &["calculate"], + &["calculated"], + &["calculator"], + &["calculates"], &["calculating"], - &["calculations"], + &["calculations", "calculation"], &["calculations"], &["calculator"], &["calculators"], + &["calculate"], + &["calculations"], &["calcium"], &["calculator"], + &["calculation"], &["calculator"], &["calculator"], + &["calculatable", "calculable"], &["calculator"], &["calculators"], &["calculations"], @@ -80974,9 +153701,27 @@ pub static WORD_CALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["calculators"], &["calculator"], &["calculations"], + &["calculated"], + &["calculator"], + &["calculation"], + &["calculations"], + &["calculation"], + &["calculations"], + &["calculate"], + &["calculation"], + &["calculated"], &["calculus"], + &["calculate"], + &["calculated"], + &["calculator"], + &["calculating"], + &["calculator"], + &["calculating"], + &["calculations"], + &["calculate"], + &["calculated"], ], - range: 3..=8, + range: 3..=9, }; static WORD_CALB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81003,8 +153748,9 @@ pub static WORD_CALA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("ber"), dictgen::InsensitiveStr::Ascii("gry"), + dictgen::InsensitiveStr::Ascii("log"), ], - values: &[&["caliber"], &["calgary"]], + values: &[&["caliber"], &["calgary"], &["catalog"]], range: 3..=3, }; @@ -81030,20 +153776,104 @@ static WORD_CAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("gned"), + 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: &[ - &["cached"], - &["chaotic"], + &["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"], + &["changed"], + &["changes"], + &["changing"], + &["channel"], + &["channels"], + &["chained"], + &["caching"], + &["chaining"], + &["change"], + &["changed"], + &["changes"], + &["changing"], + &["channel"], + &["channels"], + &["chaotic"], + &["char"], + &["character"], + &["characters"], + &["charging"], + &["chars"], &["cashier"], &["cashiers"], ], - range: 4..=7, + range: 1..=8, }; static WORD_CAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81071,6 +153901,28 @@ pub static WORD_CAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 4..=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")], + values: &[&["carefully"]], + range: 5..=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, @@ -81078,8 +153930,31 @@ static WORD_CAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("l"), + dictgen::InsensitiveStr::Ascii("late"), dictgen::InsensitiveStr::Ascii("lium"), + 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("lulating"), @@ -81089,14 +153964,44 @@ pub static WORD_CAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("lulators"), dictgen::InsensitiveStr::Ascii("lulus"), 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"], + &["calc"], + &["calculate"], &["calcium"], &["calculate"], &["calculated"], + &["calculator"], + &["calculates"], + &["calculating"], + &["calculation"], + &["calculations"], + &["calculator"], + &["calculate"], + &["calculation"], + &["calculations"], + &["calculator"], + &["calculate"], + &["calculated"], &["calculating"], &["calculation"], &["calculations"], @@ -81104,10 +154009,17 @@ pub static WORD_CAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["calculators"], &["calculus"], &["caucasian"], + &["calculate"], + &["calculated"], + &["calculator"], + &["calculates"], + &["calculating"], + &["calculation"], + &["calculations"], &["calculator"], &["caucuses"], ], - range: 4..=9, + range: 1..=9, }; static WORD_CAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81150,19 +154062,19 @@ static WORD_B_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_BA_NODE), - None, + Some(&WORD_BB_NODE), Some(&WORD_BC_NODE), None, Some(&WORD_BE_NODE), - None, - None, + Some(&WORD_BF_NODE), + Some(&WORD_BG_NODE), None, Some(&WORD_BI_NODE), - None, + Some(&WORD_BJ_NODE), None, Some(&WORD_BL_NODE), None, - None, + Some(&WORD_BN_NODE), Some(&WORD_BO_NODE), None, None, @@ -81170,8 +154082,8 @@ static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> None, Some(&WORD_BT_NODE), Some(&WORD_BU_NODE), - None, - None, + Some(&WORD_BV_NODE), + Some(&WORD_BW_NODE), None, Some(&WORD_BY_NODE), None, @@ -81183,9 +154095,43 @@ static WORD_BY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_BY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("cicles")], - values: &[&["bicycles"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("cicles"), + dictgen::InsensitiveStr::Ascii("pas"), + dictgen::InsensitiveStr::Ascii("pased"), + dictgen::InsensitiveStr::Ascii("pasing"), + dictgen::InsensitiveStr::Ascii("teoder"), + ], + values: &[ + &["bicycles"], + &["bypass"], + &["bypassed"], + &["bypassing"], + &["byteorder"], + ], + range: 3..=6, +}; + +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 { @@ -81194,27 +154140,27 @@ static WORD_BU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_BUA_NODE), Some(&WORD_BUB_NODE), None, Some(&WORD_BUD_NODE), Some(&WORD_BUE_NODE), - None, + Some(&WORD_BUF_NODE), Some(&WORD_BUG_NODE), Some(&WORD_BUH_NODE), Some(&WORD_BUI_NODE), None, None, Some(&WORD_BUL_NODE), - None, - None, + 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), - None, + Some(&WORD_BUU_NODE), None, None, None, @@ -81222,6 +154168,21 @@ static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, ]; +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, @@ -81231,6 +154192,8 @@ pub static WORD_BUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("cherd"), dictgen::InsensitiveStr::Ascii("hcered"), + dictgen::InsensitiveStr::Ascii("on"), + dictgen::InsensitiveStr::Ascii("ons"), dictgen::InsensitiveStr::Ascii("terey"), dictgen::InsensitiveStr::Ascii("terfies"), dictgen::InsensitiveStr::Ascii("terfiles"), @@ -81240,14 +154203,22 @@ pub static WORD_BUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tom"), + dictgen::InsensitiveStr::Ascii("toms"), + dictgen::InsensitiveStr::Ascii("tosn"), dictgen::InsensitiveStr::Ascii("trey"), + dictgen::InsensitiveStr::Ascii("tton"), + dictgen::InsensitiveStr::Ascii("ttons"), ], values: &[ &["butchered"], &["butchered"], + &["button"], + &["buttons"], &["buttery"], &["butterflies"], &["butterflies"], @@ -81257,12 +154228,18 @@ pub static WORD_BUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["butterfly"], &["butterflies"], &["butterfly"], + &["butterfly"], &["buttery"], &["butthole"], &["butthole"], + &["button", "bottom"], + &["buttons", "bottom"], + &["buttons"], &["buttery"], + &["button"], + &["buttons"], ], - range: 4..=8, + range: 2..=8, }; static WORD_BUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81286,10 +154263,11 @@ pub static WORD_BUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("niessmen"), dictgen::InsensitiveStr::Ascii("rting"), dictgen::InsensitiveStr::Ascii("siness"), + dictgen::InsensitiveStr::Ascii("sy"), ], values: &[ &["business"], - &["business"], + &["business", "businesses"], &["businessman"], &["businessmen"], &["businessman"], @@ -81302,8 +154280,9 @@ pub static WORD_BUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["businessmen"], &["bursting"], &["business"], + &["busy"], ], - range: 4..=9, + range: 2..=9, }; static WORD_BUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81330,6 +154309,7 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -81341,6 +154321,7 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("isers"), dictgen::InsensitiveStr::Ascii("lgar"), dictgen::InsensitiveStr::Ascii("nign"), + dictgen::InsensitiveStr::Ascii("ocratic"), dictgen::InsensitiveStr::Ascii("ried"), dictgen::InsensitiveStr::Ascii("riots"), dictgen::InsensitiveStr::Ascii("ritio"), @@ -81352,6 +154333,7 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tality"), dictgen::InsensitiveStr::Ascii("tally"), dictgen::InsensitiveStr::Ascii("tsing"), + dictgen::InsensitiveStr::Ascii("tst"), dictgen::InsensitiveStr::Ascii("ueacrats"), ], values: &[ @@ -81373,16 +154355,18 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bureaucrats"], &["bureaucracy"], &["bureaucracy"], + &["bureaucracy"], &["bureaucratic"], &["bureaucrats"], &["burgundy"], &["burgundy"], &["burgundy"], - &["burying"], + &["burying", "burning", "burin", "during"], &["bruiser"], &["bruisers"], &["burglar"], &["burning"], + &["bureaucratic"], &["buried"], &["burritos"], &["burrito"], @@ -81394,6 +154378,7 @@ pub static WORD_BUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["brutality"], &["brutally"], &["bursting"], + &["burst"], &["bureaucrats"], ], range: 3..=12, @@ -81410,6 +154395,35 @@ pub static WORD_BUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("del"), + dictgen::InsensitiveStr::Ascii("deled"), + ], + values: &[&["bundle"], &["bundled"]], + range: 3..=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("pded"), + dictgen::InsensitiveStr::Ascii("pted"), + ], + values: &[&["bump"], &["bumped"], &["bumped"]], + range: 1..=4, +}; + static WORD_BUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_BUL_CHILDREN), value: None, @@ -81418,12 +154432,19 @@ static WORD_BUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ds"), dictgen::InsensitiveStr::Ascii("gaira"), dictgen::InsensitiveStr::Ascii("gara"), dictgen::InsensitiveStr::Ascii("gariska"), + 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"), @@ -81432,17 +154453,27 @@ pub static WORD_BUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("letproff"), dictgen::InsensitiveStr::Ascii("letprooof"), dictgen::InsensitiveStr::Ascii("letprrof"), + dictgen::InsensitiveStr::Ascii("letted"), dictgen::InsensitiveStr::Ascii("letts"), dictgen::InsensitiveStr::Ascii("litproof"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("tin"), ], values: &[ &["bulgaria"], + &["build"], + &["building"], + &["builds"], &["bulgaria"], &["bulgaria"], &["bulgaria"], + &["build"], &["builders"], &["building"], &["buildings"], + &["builds"], + &["built"], + &["bullet"], &["bulletproof"], &["bullets"], &["bulletproof"], @@ -81451,10 +154482,13 @@ pub static WORD_BUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bulletproof"], &["bulletproof"], &["bulletproof"], + &["bulleted"], &["bullets"], &["bulletproof"], + &["built"], + &["builtin"], ], - range: 4..=9, + range: 1..=9, }; static WORD_BUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81464,28 +154498,66 @@ static WORD_BUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("d"), + dictgen::InsensitiveStr::Ascii("ding"), dictgen::InsensitiveStr::Ascii("dlers"), dictgen::InsensitiveStr::Ascii("dling"), dictgen::InsensitiveStr::Ascii("dlings"), + dictgen::InsensitiveStr::Ascii("ild"), + dictgen::InsensitiveStr::Ascii("k"), + dictgen::InsensitiveStr::Ascii("l"), + dictgen::InsensitiveStr::Ascii("lded"), dictgen::InsensitiveStr::Ascii("ldes"), dictgen::InsensitiveStr::Ascii("ldins"), + dictgen::InsensitiveStr::Ascii("llt"), + dictgen::InsensitiveStr::Ascii("lter"), + dictgen::InsensitiveStr::Ascii("lters"), + dictgen::InsensitiveStr::Ascii("pd"), 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"], + &["building"], &["builders"], &["building"], &["buildings"], + &["build"], + &["bulk"], + &["build", "built"], + &["built"], &["builders"], &["buildings"], + &["built"], + &["builder"], + &["builders"], + &["build"], &["business"], &["businesses"], &["businessman"], &["businessmen"], + &["business"], + &["businesses"], + &["built"], + &["builtin"], + &["builtins"], + &["builtin"], + &["builtins"], + &["button"], + &["buttons"], ], - range: 4..=8, + range: 1..=9, }; static WORD_BUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81511,10 +154583,64 @@ static WORD_BUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("dets"), + dictgen::InsensitiveStr::Ascii("gest"), dictgen::InsensitiveStr::Ascii("laria"), + dictgen::InsensitiveStr::Ascii("ous"), + dictgen::InsensitiveStr::Ascii("uous"), + dictgen::InsensitiveStr::Ascii("us"), ], - values: &[&["budgets"], &["bulgaria"]], - range: 4..=5, + values: &[ + &["budgets"], + &["biggest"], + &["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("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"], + &["buffer"], + &["buffer"], + &["buffers"], + &["buffer"], + &["buffers"], + &["buffer"], + &["buffered"], + &["buffering"], + &["buffer"], + ], + range: 2..=6, }; static WORD_BUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81593,6 +154719,17 @@ pub static WORD_BUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -81602,9 +154739,11 @@ pub static WORD_BT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg keys: &[ dictgen::InsensitiveStr::Ascii("iched"), dictgen::InsensitiveStr::Ascii("iches"), + dictgen::InsensitiveStr::Ascii("ye"), + dictgen::InsensitiveStr::Ascii("yes"), ], - values: &[&["bitched"], &["bitches"]], - range: 5..=5, + values: &[&["bitched"], &["bitches"], &["byte"], &["bytes"]], + range: 2..=5, }; static WORD_BR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -81618,7 +154757,7 @@ static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, Some(&WORD_BRE_NODE), - None, + Some(&WORD_BRF_NODE), None, None, Some(&WORD_BRI_NODE), @@ -81626,7 +154765,7 @@ static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, None, None, - None, + Some(&WORD_BRN_NODE), Some(&WORD_BRO_NODE), None, None, @@ -81635,12 +154774,37 @@ static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_BRT_NODE), Some(&WORD_BRU_NODE), None, - 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, @@ -81704,68 +154868,295 @@ pub static WORD_BRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_BRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_BRO_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_BRO_CHILDREN), value: None, }; -pub static WORD_BRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + None, + None, + None, + Some(&WORD_BROK_NODE), + None, + None, + Some(&WORD_BRON_NODE), + None, + 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("acasted"), - dictgen::InsensitiveStr::Ascii("adacasting"), - dictgen::InsensitiveStr::Ascii("adbad"), - dictgen::InsensitiveStr::Ascii("adcasing"), - dictgen::InsensitiveStr::Ascii("adcastes"), - dictgen::InsensitiveStr::Ascii("adcastors"), - dictgen::InsensitiveStr::Ascii("adcat"), - dictgen::InsensitiveStr::Ascii("adley"), - dictgen::InsensitiveStr::Ascii("adwalk"), - dictgen::InsensitiveStr::Ascii("ady"), - dictgen::InsensitiveStr::Ascii("coli"), - dictgen::InsensitiveStr::Ascii("colli"), - dictgen::InsensitiveStr::Ascii("daway"), - dictgen::InsensitiveStr::Ascii("derlands"), - dictgen::InsensitiveStr::Ascii("ncoes"), - dictgen::InsensitiveStr::Ascii("nocs"), + 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"), - dictgen::InsensitiveStr::Ascii("therhod"), - dictgen::InsensitiveStr::Ascii("therhoood"), - dictgen::InsensitiveStr::Ascii("therood"), - dictgen::InsensitiveStr::Ascii("therwood"), - dictgen::InsensitiveStr::Ascii("wine"), - dictgen::InsensitiveStr::Ascii("wines"), - dictgen::InsensitiveStr::Ascii("wisng"), - dictgen::InsensitiveStr::Ascii("wnei"), - dictgen::InsensitiveStr::Ascii("wnis"), + ], + 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_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_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("casted"), + 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"], &["broadcasting"], &["broadband"], + &["broadcast"], + &["broadcast"], &["broadcasting"], &["broadcasts"], + &["broadcast"], &["broadcasts"], - &["broadcasts"], + &["broadcasts", "broadcast"], &["broadly"], &["boardwalk"], &["broadly"], - &["broccoli"], - &["broccoli"], - &["broadway"], - &["borderlands"], - &["broncos"], - &["broncos"], - &["browsing"], - &["brotherhood"], - &["brotherhood"], - &["brotherhood"], - &["brotherhood"], - &["brownie"], - &["brownies"], - &["browsing"], - &["brownie"], - &["brownies"], + &["broadcast"], ], - range: 3..=10, + 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 { @@ -81782,16 +155173,24 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("daging"), dictgen::InsensitiveStr::Ascii("dman"), dictgen::InsensitiveStr::Ascii("elfy"), + dictgen::InsensitiveStr::Ascii("evely"), 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("gthness"), dictgen::InsensitiveStr::Ascii("liant"), + dictgen::InsensitiveStr::Ascii("linear"), dictgen::InsensitiveStr::Ascii("llaince"), dictgen::InsensitiveStr::Ascii("llaintly"), dictgen::InsensitiveStr::Ascii("llant"), @@ -81800,6 +155199,8 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("thday"), @@ -81820,16 +155221,24 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["brigading"], &["birdman"], &["briefly"], + &["briefly"], &["brigade"], &["brigade"], + &["bridge"], &["bridges"], + &["bridge"], + &["bridges"], + &["brightness"], &["brighten"], &["brighten"], + &["brightness"], &["brighten"], + &["bright"], &["brighten"], &["brightest"], &["brightness"], &["brilliant"], + &["bilinear"], &["brilliance"], &["brilliantly"], &["brilliant"], @@ -81838,6 +155247,8 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["brilliantly"], &["brimstone"], &["birmingham"], + &["bringing"], + &["bringtofront"], &["brisbane"], &["bristol"], &["birthday"], @@ -81850,23 +155261,38 @@ pub static WORD_BRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bruisers"], &["bruises"], ], - range: 4..=9, + 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: None, + value: Some(&["be", "brie"]), }; pub static WORD_BRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ 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("astfeading"), dictgen::InsensitiveStr::Ascii("astfeedig"), dictgen::InsensitiveStr::Ascii("astfeeing"), @@ -81876,12 +155302,21 @@ pub static WORD_BRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("athtakng"), 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"), @@ -81893,11 +155328,15 @@ pub static WORD_BRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["breastfeeding"], &["breakdowns"], + &["breaks"], &["breakthrough"], &["breakthrough"], &["breakthroughs"], &["breakthrough"], &["breakthrough"], + &["breakthroughs"], + &["breakthrough"], + &["break"], &["breastfeeding"], &["breastfeeding"], &["breastfeeding"], @@ -81907,12 +155346,21 @@ pub static WORD_BRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["breathtaking"], &["breastfeeding"], &["brendan"], + &["brief", "beef"], + &["briefly"], + &["before"], &["brief"], &["briefly"], &["breakout"], + &["breakpoint"], + &["breakpoints"], &["brendan"], &["berserk"], &["berserker"], + &["brush", "fresh"], + &["brushed"], + &["brushes"], + &["brushing"], &["brethren"], &["brethren"], &["brewers"], @@ -81936,6 +155384,10 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("celettes"), dictgen::InsensitiveStr::Ascii("celetts"), dictgen::InsensitiveStr::Ascii("celona"), + dictgen::InsensitiveStr::Ascii("cese"), + dictgen::InsensitiveStr::Ascii("ch"), + dictgen::InsensitiveStr::Ascii("ckeds"), + dictgen::InsensitiveStr::Ascii("ckground"), dictgen::InsensitiveStr::Ascii("dcast"), dictgen::InsensitiveStr::Ascii("dfrod"), dictgen::InsensitiveStr::Ascii("evry"), @@ -81948,9 +155400,20 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("keout"), dictgen::InsensitiveStr::Ascii("kethrough"), dictgen::InsensitiveStr::Ascii("kley"), + dictgen::InsensitiveStr::Ascii("kpoint"), + dictgen::InsensitiveStr::Ascii("kpoints"), + dictgen::InsensitiveStr::Ascii("nce"), + dictgen::InsensitiveStr::Ascii("nchces"), + dictgen::InsensitiveStr::Ascii("nchs"), + dictgen::InsensitiveStr::Ascii("nck"), + dictgen::InsensitiveStr::Ascii("nckes"), + dictgen::InsensitiveStr::Ascii("ncket"), + dictgen::InsensitiveStr::Ascii("nckets"), + dictgen::InsensitiveStr::Ascii("ne"), dictgen::InsensitiveStr::Ascii("nier"), dictgen::InsensitiveStr::Ascii("odband"), dictgen::InsensitiveStr::Ascii("odcast"), + dictgen::InsensitiveStr::Ascii("odcasted"), dictgen::InsensitiveStr::Ascii("odcasting"), dictgen::InsensitiveStr::Ascii("odcasts"), dictgen::InsensitiveStr::Ascii("oden"), @@ -81960,6 +155423,7 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("sillian"), dictgen::InsensitiveStr::Ascii("tenders"), dictgen::InsensitiveStr::Ascii("verly"), + dictgen::InsensitiveStr::Ascii("zeer"), dictgen::InsensitiveStr::Ascii("zilains"), dictgen::InsensitiveStr::Ascii("zileans"), dictgen::InsensitiveStr::Ascii("ziliaan"), @@ -81969,6 +155433,7 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ziliians"), dictgen::InsensitiveStr::Ascii("zilions"), dictgen::InsensitiveStr::Ascii("zillans"), + dictgen::InsensitiveStr::Ascii("zillian"), ], values: &[ &["barbarian"], @@ -81976,6 +155441,10 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bracelets"], &["bracelets"], &["barcelona"], + &["braces"], + &["branch"], + &["brackets"], + &["background"], &["broadcast"], &["bradford"], &["bravery"], @@ -81988,9 +155457,20 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["breakout"], &["breakthrough"], &["barkley"], + &["breakpoint"], + &["breakpoints"], + &["branch", "brace", "branches"], + &["branches"], + &["branches"], + &["branch"], + &["branches"], + &["bracket"], + &["brackets"], + &["brain"], &["brainer"], &["broadband"], &["broadcast"], + &["broadcasted"], &["broadcasting"], &["broadcasts"], &["broaden"], @@ -82000,6 +155480,7 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["brazilian"], &["bartenders"], &["bravery"], + &["brassiere"], &["brazilians"], &["brazilians"], &["brazilians"], @@ -82009,8 +155490,9 @@ pub static WORD_BRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["brazilians"], &["brazilians"], &["brazilians"], + &["brazilian"], ], - range: 4..=9, + range: 2..=9, }; static WORD_BO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82021,13 +155503,13 @@ static WORD_BO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_BOA_NODE), Some(&WORD_BOB_NODE), - None, + Some(&WORD_BOC_NODE), Some(&WORD_BOD_NODE), None, + Some(&WORD_BOF_NODE), + Some(&WORD_BOG_NODE), None, - None, - None, - None, + Some(&WORD_BOI_NODE), None, None, Some(&WORD_BOL_NODE), @@ -82035,14 +155517,14 @@ static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_BON_NODE), Some(&WORD_BOO_NODE), None, - None, + Some(&WORD_BOQ_NODE), Some(&WORD_BOR_NODE), Some(&WORD_BOS_NODE), Some(&WORD_BOT_NODE), Some(&WORD_BOU_NODE), None, None, - None, + Some(&WORD_BOX_NODE), Some(&WORD_BOY_NODE), None, ]; @@ -82055,6 +155537,7 @@ static WORD_BOY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -82067,6 +155550,7 @@ pub static WORD_BOY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["buoyant"], + &["boycott"], &["boycotting"], &["boycotting"], &["boyfriend"], @@ -82080,51 +155564,334 @@ pub static WORD_BOY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 3..=8, }; -static WORD_BOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_BOU_CHILDREN), +static WORD_BOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_BOX_CHILDREN), value: None, }; -pub static WORD_BOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_BOX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("dler"), - dictgen::InsensitiveStr::Ascii("ldore"), - dictgen::InsensitiveStr::Ascii("ndaires"), - dictgen::InsensitiveStr::Ascii("nderies"), - dictgen::InsensitiveStr::Ascii("ndry"), - dictgen::InsensitiveStr::Ascii("nites"), - dictgen::InsensitiveStr::Ascii("nses"), - dictgen::InsensitiveStr::Ascii("regois"), - dictgen::InsensitiveStr::Ascii("rgeios"), - dictgen::InsensitiveStr::Ascii("rgeoius"), - dictgen::InsensitiveStr::Ascii("rgeousie"), - dictgen::InsensitiveStr::Ascii("rgoeis"), - dictgen::InsensitiveStr::Ascii("tiqe"), - dictgen::InsensitiveStr::Ascii("tnies"), - dictgen::InsensitiveStr::Ascii("tqiue"), - dictgen::InsensitiveStr::Ascii("yancy"), - dictgen::InsensitiveStr::Ascii("yant"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[&["boxes", "box", "boxer"], &["box"]], + range: 1..=1, +}; + +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: &[ - &["boulder"], - &["boulder"], + &["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::Flat(&WORD_BOUN_CHILDREN), + value: Some(&["bound"]), +}; + +pub static WORD_BOUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("aaries"), + dictgen::InsensitiveStr::Ascii("aary"), + dictgen::InsensitiveStr::Ascii("ad"), + dictgen::InsensitiveStr::Ascii("adaries"), + dictgen::InsensitiveStr::Ascii("adary"), + dictgen::InsensitiveStr::Ascii("aded"), + dictgen::InsensitiveStr::Ascii("ading"), + dictgen::InsensitiveStr::Ascii("adries"), + dictgen::InsensitiveStr::Ascii("adry"), + dictgen::InsensitiveStr::Ascii("ads"), + dictgen::InsensitiveStr::Ascii("ardies"), + dictgen::InsensitiveStr::Ascii("ardy"), + dictgen::InsensitiveStr::Ascii("aries"), + dictgen::InsensitiveStr::Ascii("ary"), + dictgen::InsensitiveStr::Ascii("bdaries"), + dictgen::InsensitiveStr::Ascii("bdary"), + dictgen::InsensitiveStr::Ascii("daires"), + dictgen::InsensitiveStr::Ascii("dares"), + dictgen::InsensitiveStr::Ascii("daryi"), + dictgen::InsensitiveStr::Ascii("darys"), + dictgen::InsensitiveStr::Ascii("day"), + dictgen::InsensitiveStr::Ascii("days"), + dictgen::InsensitiveStr::Ascii("deries"), + dictgen::InsensitiveStr::Ascii("dery"), + dictgen::InsensitiveStr::Ascii("dig"), + dictgen::InsensitiveStr::Ascii("dimg"), + dictgen::InsensitiveStr::Ascii("drary"), + dictgen::InsensitiveStr::Ascii("dries"), + dictgen::InsensitiveStr::Ascii("dry"), + dictgen::InsensitiveStr::Ascii("duaries"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("garies"), + dictgen::InsensitiveStr::Ascii("gary"), + dictgen::InsensitiveStr::Ascii("gin"), + dictgen::InsensitiveStr::Ascii("gind"), + dictgen::InsensitiveStr::Ascii("hdaries"), + dictgen::InsensitiveStr::Ascii("hdary"), + dictgen::InsensitiveStr::Ascii("idng"), + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ites"), + dictgen::InsensitiveStr::Ascii("nd"), + dictgen::InsensitiveStr::Ascii("nded"), + dictgen::InsensitiveStr::Ascii("nding"), + dictgen::InsensitiveStr::Ascii("nds"), + dictgen::InsensitiveStr::Ascii("radies"), + dictgen::InsensitiveStr::Ascii("rady"), + dictgen::InsensitiveStr::Ascii("raies"), + dictgen::InsensitiveStr::Ascii("raries"), + dictgen::InsensitiveStr::Ascii("rary"), + dictgen::InsensitiveStr::Ascii("ray"), + dictgen::InsensitiveStr::Ascii("s"), + dictgen::InsensitiveStr::Ascii("saries"), + dictgen::InsensitiveStr::Ascii("sary"), + dictgen::InsensitiveStr::Ascii("sd"), + dictgen::InsensitiveStr::Ascii("ses"), + dictgen::InsensitiveStr::Ascii("t"), + dictgen::InsensitiveStr::Ascii("tries"), + dictgen::InsensitiveStr::Ascii("try"), + dictgen::InsensitiveStr::Ascii("udaries"), + dictgen::InsensitiveStr::Ascii("udary"), + dictgen::InsensitiveStr::Ascii("us"), + ], + values: &[ + &["boundaries"], + &["boundary"], + &["bound"], + &["boundaries"], + &["boundary"], + &["bounded"], + &["bounding"], + &["boundaries"], + &["boundary"], + &["bounds"], + &["boundaries"], + &["boundary"], + &["boundaries"], + &["boundary"], + &["boundaries"], + &["boundary"], &["boundaries"], &["boundaries"], &["boundary"], + &["boundaries"], + &["boundary"], + &["boundaries"], + &["boundaries"], + &["boundary"], + &["bounding"], + &["bounding"], + &["boundary"], + &["boundaries"], + &["boundary"], + &["boundaries"], + &["bounded"], + &["boundaries"], + &["boundary"], + &["bounding"], + &["bounding"], + &["boundaries"], + &["boundary"], + &["bounding"], + &["bounding"], &["bounties"], + &["bound"], + &["bounded"], + &["bounding"], + &["bounds"], + &["boundaries"], + &["boundary"], + &["boundaries"], + &["boundaries"], + &["boundary"], + &["boundary"], + &["bounds"], + &["boundaries"], + &["boundary"], + &["bounds"], &["bonuses"], - &["bourgeois"], - &["bourgeois"], - &["bourgeois"], - &["bourgeois"], - &["bourgeois"], - &["boutique"], - &["bounties"], - &["boutique"], - &["buoyancy"], - &["buoyant"], + &["bound"], + &["boundaries"], + &["boundary"], + &["boundaries"], + &["boundary"], + &["bonus"], ], - range: 4..=8, + range: 1..=7, +}; + +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("es"), + ], + values: &[&["bounce"], &["bounces"]], + range: 1..=2, }; static WORD_BOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82134,12 +155901,44 @@ static WORD_BOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("telneck"), 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("tomborde"), + dictgen::InsensitiveStr::Ascii("tome"), + dictgen::InsensitiveStr::Ascii("ton"), + dictgen::InsensitiveStr::Ascii("tons"), + dictgen::InsensitiveStr::Ascii("ttom"), ], - values: &[&["motivational"], &["bottleneck"], &["bottleneck"]], - range: 7..=9, + values: &[ + &["both"], + &["both"], + &["notifies"], + &["motivational"], + &["bottleneck"], + &["bottleneck"], + &["bottleneck"], + &["bottlenecks"], + &["bottleneck"], + &["bottlenecks"], + &["bottleneck"], + &["bottlenecks"], + &["bottomborder"], + &["bottom"], + &["bottom", "button"], + &["bottoms", "buttons"], + &["bottom"], + ], + range: 2..=9, }; static WORD_BOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82148,9 +155947,12 @@ static WORD_BOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("lter")], - values: &[&["bolster"]], - range: 4..=4, + 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 { @@ -82160,6 +155962,7 @@ static WORD_BOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ad"), dictgen::InsensitiveStr::Ascii("adband"), dictgen::InsensitiveStr::Ascii("adcast"), dictgen::InsensitiveStr::Ascii("adcasting"), @@ -82169,17 +155972,27 @@ pub static WORD_BOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: &[ + &["board"], &["broadband"], &["broadcast"], &["broadcasting"], @@ -82189,19 +156002,39 @@ pub static WORD_BOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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, @@ -82209,26 +156042,102 @@ static WORD_BOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("d"), 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("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("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"), ], values: &[ + &["boot"], &["bookmarks"], + &["bookkeeping"], + &["bookkeeping"], + &["bookkeeping"], + &["bookkeep"], + &["bookmark"], &["bookmarked"], &["bookmarks"], + &["bookmark"], &["bookmarked"], &["bookmarks"], + &["bold", "bool"], + &["boolean"], + &["boolean"], + &["booleans"], + &["booleans"], + &["booleans"], + &["boolean"], + &["booleans"], + &["boolean"], + &["booleans"], + &["bootloader"], + &["bootloaders"], + &["bookmark"], + &["bookmarks"], &["book"], + &["boolean"], + &["booleans"], + &["bootstrap"], + &["bootstrapped"], + &["bootstrapping"], + &["bootstraps"], + &["boutique"], + &["bootloader"], + &["bootloaders"], &["bootloader"], &["bootloader"], + &["bottom"], + &["bootstrapping"], + &["bootram"], + &["bootstrap"], + &["bootstrap"], + &["bootstrapped"], + &["bootstrapping"], + &["bootstraps"], ], - range: 2..=7, + range: 1..=9, }; static WORD_BON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82278,11 +156187,59 @@ static WORD_BOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["bollocks"], &["bollocks"]], - range: 4..=5, + 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("nter")], + values: &[&["pointer"]], + range: 4..=4, +}; + +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("gus"), + dictgen::InsensitiveStr::Ascii("os"), + ], + values: &[&["bogus"], &["bogus"]], + range: 2..=3, +}; + +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"), + ], + values: &[&["buffer"], &["before"]], + range: 3..=3, }; static WORD_BOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82292,6 +156249,7 @@ static WORD_BOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("dy"), dictgen::InsensitiveStr::Ascii("ybuidling"), dictgen::InsensitiveStr::Ascii("ybuildig"), dictgen::InsensitiveStr::Ascii("ybuildng"), @@ -82305,6 +156263,7 @@ pub static WORD_BOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ywieght"), ], values: &[ + &["body"], &["bodybuilding"], &["bodybuilding"], &["bodybuilding"], @@ -82317,7 +156276,18 @@ pub static WORD_BOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bodyweight"], &["bodyweight"], ], - range: 6..=9, + 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 { @@ -82327,11 +156297,12 @@ static WORD_BOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["bombers"], &["bodybuilding"]], - range: 4..=9, + values: &[&["board", "bombard"], &["bombers"], &["bodybuilding"]], + range: 3..=9, }; static WORD_BOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82341,6 +156312,7 @@ static WORD_BOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -82349,16 +156321,28 @@ pub static WORD_BOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ut"), ], values: &[ + &["boards"], &["broadband"], &["broadcast"], &["broadcasting"], &["broadcasts"], &["broadway"], - &["bout"], + &["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")], + values: &[&["because"]], + range: 6..=6, +}; + static WORD_BL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_BL_CHILDREN), value: None, @@ -82366,8 +156350,8 @@ static WORD_BL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_BL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_BLA_NODE), - None, - None, + Some(&WORD_BLB_NODE), + Some(&WORD_BLC_NODE), None, Some(&WORD_BLE_NODE), None, @@ -82410,9 +156394,15 @@ pub static WORD_BLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -82426,10 +156416,16 @@ pub static WORD_BLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["blueprints"], &["blueprints"], &["bluetooth"], + &["bluetooth"], + &["bluetooth"], + &["bluetooth"], &["bulgaria"], &["bullets"], + &["blurred"], + &["blur", "blurred"], + &["bluetooth"], ], - range: 4..=9, + range: 2..=9, }; static WORD_BLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82439,14 +156435,45 @@ static WORD_BLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("odboner"), dictgen::InsensitiveStr::Ascii("odbonre"), dictgen::InsensitiveStr::Ascii("odboorne"), @@ -82456,16 +156483,48 @@ pub static WORD_BLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("odporne"), dictgen::InsensitiveStr::Ascii("orborne"), dictgen::InsensitiveStr::Ascii("ster"), + dictgen::InsensitiveStr::Ascii("ted"), ], values: &[ + &["bloat"], + &["bloated"], + &["blockack"], + &["blocks"], + &["blocked"], &["blockchain"], &["blockchain"], &["blockchain"], &["blockchain"], &["blockers"], &["blockers"], + &["blockchain"], + &["blockchains"], + &["blocking"], + &["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"], &["bloodborne"], &["bloodborne"], &["bloodborne"], @@ -82475,8 +156534,9 @@ pub static WORD_BLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bloodborne"], &["bloodborne"], &["bolster"], + &["bloated"], ], - range: 4..=8, + range: 1..=8, }; static WORD_BLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82486,13 +156546,20 @@ static WORD_BLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["blisters"], &["blitzkrieg"], &["blizzard"], &["blizzcon"]], - range: 4..=7, + values: &[ + &["blindly"], + &["blisters"], + &["blitzkrieg"], + &["blizzard"], + &["blizzcon"], + ], + range: 3..=7, }; static WORD_BLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82502,22 +156569,53 @@ static WORD_BLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: 4..=6, + 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 { @@ -82544,11 +156642,21 @@ pub static WORD_BLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -82558,6 +156666,8 @@ pub static WORD_BLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: &[ @@ -82578,11 +156688,21 @@ pub static WORD_BLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["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"], @@ -82592,9 +156712,25 @@ pub static WORD_BLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["blasphemy"], &["blatantly"], &["blatantly"], + &["blatant"], + &["blatantly"], &["baltimore"], ], - range: 2..=9, + 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 { @@ -82611,11 +156747,11 @@ static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_BIF_NODE), Some(&WORD_BIG_NODE), None, - None, + Some(&WORD_BII_NODE), None, None, Some(&WORD_BIL_NODE), - None, + Some(&WORD_BIM_NODE), Some(&WORD_BIN_NODE), Some(&WORD_BIO_NODE), Some(&WORD_BIP_NODE), @@ -82623,7 +156759,7 @@ static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_BIR_NODE), Some(&WORD_BIS_NODE), Some(&WORD_BIT_NODE), - None, + Some(&WORD_BIU_NODE), None, None, None, @@ -82637,9 +156773,24 @@ static WORD_BIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("zare")], - values: &[&["bizarre"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("are"), + dictgen::InsensitiveStr::Ascii("arely"), + dictgen::InsensitiveStr::Ascii("zare"), + ], + values: &[&["bizarre"], &["bizarrely"], &["bizarre"]], + range: 3..=5, +}; + +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 { @@ -82649,11 +156800,18 @@ static WORD_BIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -82663,11 +156821,18 @@ pub static WORD_BIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("terwseet"), ], values: &[ + &["bitmaps"], + &["bitmap"], &["bitcoin"], &["bitcoins"], &["bitcoins"], + &["bitfield"], + &["bitfields"], &["bitched"], &["bitches"], + &["bits"], + &["bitmask"], + &["bitmaps"], &["bitcoin"], &["bitcoins"], &["bittersweet"], @@ -82676,7 +156841,7 @@ pub static WORD_BIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bittersweet"], &["bittersweet"], ], - range: 4..=9, + range: 2..=9, }; static WORD_BIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82686,12 +156851,32 @@ static WORD_BIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ct"), 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: &[&["bisexual"], &["bisexual"], &["bisexual"]], - range: 5..=7, + values: &[ + &["bisect"], + &["bisexual"], + &["bisexual"], + &["bisexual"], + &["business"], + &["business"], + &["business"], + &["business"], + &["bitstream"], + &["business"], + &["business"], + ], + range: 2..=7, }; static WORD_BIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82705,10 +156890,14 @@ pub static WORD_BIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -82722,10 +156911,14 @@ pub static WORD_BIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bridges"], &["brigade"], &["brigading"], + &["bright"], + &["brighten"], + &["brighter"], &["brightest"], &["brightness"], &["birthday"], &["birthdays"], + &["bidirectionality"], &["birmingham"], &["birmingham"], &["birmingham"], @@ -82734,7 +156927,7 @@ pub static WORD_BIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["birthdays"], &["birthdays"], ], - range: 4..=9, + range: 3..=13, }; static WORD_BIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82763,6 +156956,7 @@ pub static WORD_BIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("logicaly"), dictgen::InsensitiveStr::Ascii("logiset"), dictgen::InsensitiveStr::Ascii("logiskt"), + dictgen::InsensitiveStr::Ascii("n"), dictgen::InsensitiveStr::Ascii("plar"), ], values: &[ @@ -82774,9 +156968,10 @@ pub static WORD_BIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["biologically"], &["biologist"], &["biologist"], + &["bio"], &["bipolar"], ], - range: 4..=9, + range: 1..=9, }; static WORD_BIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82785,9 +156980,48 @@ static WORD_BIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ominal")], - values: &[&["binomial"]], - range: 6..=6, + 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"), + ], + values: &[ + &["binary"], + &["binary"], + &["binary"], + &["binary"], + &["bindings"], + &["binding"], + &["binomial"], + ], + 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 { @@ -82797,6 +157031,7 @@ static WORD_BIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -82812,11 +157047,13 @@ pub static WORD_BIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("lionaries"), dictgen::InsensitiveStr::Ascii("lioniare"), dictgen::InsensitiveStr::Ascii("lioniares"), + dictgen::InsensitiveStr::Ascii("lon"), dictgen::InsensitiveStr::Ascii("sters"), dictgen::InsensitiveStr::Ascii("zzard"), dictgen::InsensitiveStr::Ascii("zzcon"), ], values: &[ + &["bilingual"], &["bilaterally"], &["biblical"], &["billboard"], @@ -82832,11 +157069,23 @@ pub static WORD_BIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["billionaires"], &["billionaire"], &["billionaires"], + &["billion"], &["blisters"], &["blizzard"], &["blizzcon"], ], - range: 5..=10, + range: 3..=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 { @@ -82846,6 +157095,7 @@ static WORD_BIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -82855,6 +157105,7 @@ pub static WORD_BIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tory"), ], values: &[ + &["bigalloc"], &["bigfoot"], &["beginning"], &["beginning"], @@ -82894,9 +157145,19 @@ static WORD_BID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rman")], - values: &[&["birdman"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("imentionnal"), + dictgen::InsensitiveStr::Ascii("ning"), + dictgen::InsensitiveStr::Ascii("nings"), + dictgen::InsensitiveStr::Ascii("rman"), + ], + values: &[ + &["bidimensional"], + &["binding"], + &["bindings"], + &["birdman"], + ], + range: 4..=11, }; static WORD_BIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82930,8 +157191,34 @@ static WORD_BIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("nry")], - values: &[&["binary"]], + 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, }; @@ -82942,14 +157229,14 @@ static WORD_BE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_BEA_NODE), - None, + 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), - None, + Some(&WORD_BEI_NODE), Some(&WORD_BEJ_NODE), None, Some(&WORD_BEL_NODE), @@ -82962,7 +157249,7 @@ static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_BES_NODE), Some(&WORD_BET_NODE), Some(&WORD_BEU_NODE), - None, + Some(&WORD_BEV_NODE), Some(&WORD_BEW_NODE), None, Some(&WORD_BEY_NODE), @@ -82975,9 +157262,13 @@ static WORD_BEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("oncye")], - values: &[&["beyonce"]], - range: 5..=5, + keys: &[ + dictgen::InsensitiveStr::Ascii("oncye"), + dictgen::InsensitiveStr::Ascii("ong"), + dictgen::InsensitiveStr::Ascii("ound"), + ], + values: &[&["beyonce"], &["beyond"], &["beyond"]], + range: 3..=5, }; static WORD_BEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -82987,11 +157278,29 @@ static WORD_BEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"]], - range: 3..=4, + 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 { @@ -83004,19 +157313,27 @@ pub static WORD_BEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("raucrats"), + dictgen::InsensitiveStr::Ascii("tification"), + dictgen::InsensitiveStr::Ascii("tiful"), + dictgen::InsensitiveStr::Ascii("tifully"), ], values: &[ &["beautiful"], &["beautifully"], - &["becuase"], + &["becuase", "because"], + &["bureaucracy"], &["bureaucracy"], &["bureaucratic"], &["bureaucrats"], + &["beautification"], + &["beautiful"], + &["beautifully"], ], - range: 4..=9, + range: 4..=10, }; static WORD_BET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83027,22 +157344,41 @@ static WORD_BET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("wern"), ], values: &[ &["beatles"], &["between"], + &["between"], &["bethesda"], + &["better"], &["bethesda"], + &["between"], &["bethesda"], &["bethesda"], &["bethesda"], @@ -83050,8 +157386,21 @@ pub static WORD_BET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["betrayed"], &["betrayed"], &["between"], + &["better"], + &["better", "battery"], + &["between"], + &["between"], + &["between"], + &["between"], + &["between"], + &["between"], + &["betweenness"], + &["between"], + &["between"], + &["between"], + &["between"], ], - range: 3..=7, + range: 2..=7, }; static WORD_BES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83061,6 +157410,7 @@ static WORD_BES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ed"), dictgen::InsensitiveStr::Ascii("eige"), dictgen::InsensitiveStr::Ascii("eiged"), dictgen::InsensitiveStr::Ascii("eiging"), @@ -83071,6 +157421,7 @@ pub static WORD_BES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tiallity"), ], values: &[ + &["based"], &["besiege"], &["besieged"], &["besieging"], @@ -83080,7 +157431,7 @@ pub static WORD_BES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bestiality"], &["bestiality"], ], - range: 4..=8, + range: 2..=8, }; static WORD_BER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83092,24 +157443,30 @@ pub static WORD_BER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("aded"), dictgen::InsensitiveStr::Ascii("ekley"), + 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"], + &["performing"], &["bergamot"], &["berkeley"], + &["berkeley"], &["bernoulli"], &["berserk"], &["berserker"], &["berserker"], &["berserker"], + &["between"], ], range: 4..=7, }; @@ -83120,68 +157477,179 @@ static WORD_BEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ynce")], - values: &[&["beyonce"]], - range: 4..=4, + 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::Flat(&WORD_BEN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_BEN_CHILDREN), value: None, }; -pub static WORD_BEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + Some(&WORD_BENG_NODE), + Some(&WORD_BENH_NODE), + Some(&WORD_BENI_NODE), + None, + 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_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("agls"), - dictgen::InsensitiveStr::Ascii("chamrk"), - dictgen::InsensitiveStr::Ascii("chamrks"), - dictgen::InsensitiveStr::Ascii("chmakrs"), - dictgen::InsensitiveStr::Ascii("chmars"), - dictgen::InsensitiveStr::Ascii("ckmarks"), - dictgen::InsensitiveStr::Ascii("edicat"), - dictgen::InsensitiveStr::Ascii("edickt"), - dictgen::InsensitiveStr::Ascii("edit"), - dictgen::InsensitiveStr::Ascii("efecial"), - dictgen::InsensitiveStr::Ascii("efica"), - dictgen::InsensitiveStr::Ascii("eficary"), - dictgen::InsensitiveStr::Ascii("eficiul"), - dictgen::InsensitiveStr::Ascii("efitial"), - dictgen::InsensitiveStr::Ascii("efitical"), - dictgen::InsensitiveStr::Ascii("eifical"), - dictgen::InsensitiveStr::Ascii("elovent"), - dictgen::InsensitiveStr::Ascii("evalent"), - dictgen::InsensitiveStr::Ascii("evelant"), - dictgen::InsensitiveStr::Ascii("evelent"), - dictgen::InsensitiveStr::Ascii("evelont"), - dictgen::InsensitiveStr::Ascii("evloent"), - dictgen::InsensitiveStr::Ascii("evolant"), - dictgen::InsensitiveStr::Ascii("gahzi"), - dictgen::InsensitiveStr::Ascii("galas"), - dictgen::InsensitiveStr::Ascii("galos"), - dictgen::InsensitiveStr::Ascii("gazhi"), - dictgen::InsensitiveStr::Ascii("ghai"), - dictgen::InsensitiveStr::Ascii("ghazhi"), - dictgen::InsensitiveStr::Ascii("ghazzi"), - dictgen::InsensitiveStr::Ascii("ghzai"), - dictgen::InsensitiveStr::Ascii("glas"), - dictgen::InsensitiveStr::Ascii("gzhai"), - dictgen::InsensitiveStr::Ascii("hgazi"), - dictgen::InsensitiveStr::Ascii("idect"), - dictgen::InsensitiveStr::Ascii("ificial"), - dictgen::InsensitiveStr::Ascii("ifit"), - dictgen::InsensitiveStr::Ascii("ifits"), - dictgen::InsensitiveStr::Ascii("ovelent"), + 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"), ], values: &[ + &["benedict"], + &["beneficial"], + &["benefit"], + &["benefit"], + &["benefited"], + &["beneficial"], + &["benefits"], + &["being"], + ], + 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("hai"), + dictgen::InsensitiveStr::Ascii("hazhi"), + dictgen::InsensitiveStr::Ascii("hazzi"), + dictgen::InsensitiveStr::Ascii("hzai"), + dictgen::InsensitiveStr::Ascii("las"), + dictgen::InsensitiveStr::Ascii("zhai"), + ], + values: &[ + &["benghazi"], &["bengals"], + &["bengals"], + &["benghazi"], + &["benghazi"], + &["benghazi"], + &["benghazi"], + &["benghazi"], + &["bengals"], + &["benghazi"], + ], + range: 3..=5, +}; + +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("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"], - &["benchmarks"], - &["benchmarks"], - &["benchmarks"], + &["benchmarked"], + &["benchmarking"], &["benchmarks"], &["benedict"], &["benedict"], &["benedict"], + &["beneath"], + &["beneficial"], &["beneficial"], &["beneficial"], &["beneficiary"], @@ -83189,31 +157657,72 @@ pub static WORD_BEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["beneficial"], &["beneficial"], &["beneficial"], - &["benevolent"], - &["benevolent"], - &["benevolent"], - &["benevolent"], - &["benevolent"], - &["benevolent"], - &["benevolent"], - &["benghazi"], - &["bengals"], - &["bengals"], - &["benghazi"], - &["benghazi"], - &["benghazi"], - &["benghazi"], - &["benghazi"], - &["bengals"], - &["benghazi"], - &["benghazi"], - &["benedict"], - &["beneficial"], - &["benefit"], &["benefits"], &["benevolent"], + &["generate", "venerate"], + &["benefits"], + &["benevolent"], + &["benevolent"], + &["benevolent"], + &["benevolent"], + &["benevolent"], + &["benevolent"], ], - range: 4..=8, + 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("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"], + &["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 { @@ -83236,7 +157745,13 @@ pub static WORD_BEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("eagured"), dictgen::InsensitiveStr::Ascii("eif"), + dictgen::InsensitiveStr::Ascii("eifable"), + dictgen::InsensitiveStr::Ascii("eife"), + dictgen::InsensitiveStr::Ascii("eifed"), + dictgen::InsensitiveStr::Ascii("eifes"), + dictgen::InsensitiveStr::Ascii("eifing"), dictgen::InsensitiveStr::Ascii("eifs"), + dictgen::InsensitiveStr::Ascii("eiv"), dictgen::InsensitiveStr::Ascii("eivable"), dictgen::InsensitiveStr::Ascii("eive"), dictgen::InsensitiveStr::Ascii("eived"), @@ -83247,30 +157762,55 @@ pub static WORD_BEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("guim"), dictgen::InsensitiveStr::Ascii("iavable"), dictgen::InsensitiveStr::Ascii("iebable"), + dictgen::InsensitiveStr::Ascii("iefable"), + dictgen::InsensitiveStr::Ascii("iefe"), + dictgen::InsensitiveStr::Ascii("iefed"), dictgen::InsensitiveStr::Ascii("iefes"), + dictgen::InsensitiveStr::Ascii("iefing"), dictgen::InsensitiveStr::Ascii("ieveble"), dictgen::InsensitiveStr::Ascii("ievr"), dictgen::InsensitiveStr::Ascii("ievs"), dictgen::InsensitiveStr::Ascii("ifes"), dictgen::InsensitiveStr::Ascii("igan"), dictgen::InsensitiveStr::Ascii("igum"), + dictgen::InsensitiveStr::Ascii("ing"), dictgen::InsensitiveStr::Ascii("ittleing"), dictgen::InsensitiveStr::Ascii("ittlling"), + dictgen::InsensitiveStr::Ascii("iv"), + dictgen::InsensitiveStr::Ascii("ivable"), dictgen::InsensitiveStr::Ascii("ive"), dictgen::InsensitiveStr::Ascii("iveable"), + dictgen::InsensitiveStr::Ascii("iveably"), + dictgen::InsensitiveStr::Ascii("iveble"), + dictgen::InsensitiveStr::Ascii("ivebly"), dictgen::InsensitiveStr::Ascii("ived"), dictgen::InsensitiveStr::Ascii("iveing"), dictgen::InsensitiveStr::Ascii("ives"), + dictgen::InsensitiveStr::Ascii("iving"), dictgen::InsensitiveStr::Ascii("ligerant"), dictgen::InsensitiveStr::Ascii("ligerante"), dictgen::InsensitiveStr::Ascii("ligirent"), dictgen::InsensitiveStr::Ascii("lweather"), + dictgen::InsensitiveStr::Ascii("og"), + dictgen::InsensitiveStr::Ascii("oging"), + dictgen::InsensitiveStr::Ascii("ogs"), + dictgen::InsensitiveStr::Ascii("ond"), + dictgen::InsensitiveStr::Ascii("oning"), + dictgen::InsensitiveStr::Ascii("ove"), + dictgen::InsensitiveStr::Ascii("own"), dictgen::InsensitiveStr::Ascii("ssings"), + dictgen::InsensitiveStr::Ascii("wo"), ], values: &[ &["beleaguered"], &["belief"], + &["believable"], + &["belief", "believe"], + &["believed"], + &["beliefs", "believes"], + &["believing"], &["beliefs"], + &["believe", "belief"], &["believable"], &["believe"], &["believed"], @@ -83281,27 +157821,46 @@ pub static WORD_BEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["belgium"], &["believable"], &["believable"], - &["beliefs"], + &["believable"], + &["believe", "belief"], + &["believed"], + &["beliefs", "believes"], + &["believing"], &["believable"], &["believer"], &["believes"], &["beliefs"], &["belgian"], &["belgium"], + &["belong"], &["belittling"], &["belittling"], + &["believe", "belief"], + &["believable"], &["believe"], &["believable"], - &["believed"], + &["believably"], + &["believable"], + &["believably"], + &["believed", "beloved"], + &["believing"], + &["believes", "beliefs"], &["believing"], - &["believes"], &["belligerent"], &["belligerent"], &["belligerent"], &["bellwether"], + &["belong"], + &["belonging"], + &["belongs"], + &["belong"], + &["belonging"], + &["below", "beloved"], + &["belong"], &["blessings"], + &["below"], ], - range: 3..=9, + range: 2..=9, }; static WORD_BEJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83310,9 +157869,27 @@ static WORD_BEJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BEJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iing")], - values: &[&["beijing"]], - range: 4..=4, + 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("ginning"), + dictgen::InsensitiveStr::Ascii("nd"), + dictgen::InsensitiveStr::Ascii("nning"), + ], + values: &[&["beginning"], &["behind"], &["beginning"]], + range: 2..=7, }; static WORD_BEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83322,6 +157899,8 @@ static WORD_BEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("abviour"), + dictgen::InsensitiveStr::Ascii("aivior"), dictgen::InsensitiveStr::Ascii("aivor"), dictgen::InsensitiveStr::Ascii("aivors"), dictgen::InsensitiveStr::Ascii("aivour"), @@ -83329,6 +157908,9 @@ pub static WORD_BEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("aviorial"), dictgen::InsensitiveStr::Ascii("aviorly"), dictgen::InsensitiveStr::Ascii("avios"), + dictgen::InsensitiveStr::Ascii("avious"), + dictgen::InsensitiveStr::Ascii("avioutr"), + dictgen::InsensitiveStr::Ascii("aviuor"), dictgen::InsensitiveStr::Ascii("avoir"), dictgen::InsensitiveStr::Ascii("avoiral"), dictgen::InsensitiveStr::Ascii("avoirs"), @@ -83337,12 +157919,19 @@ pub static WORD_BEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("tesda"), dictgen::InsensitiveStr::Ascii("vaiour"), dictgen::InsensitiveStr::Ascii("vaiours"), + dictgen::InsensitiveStr::Ascii("viour"), ], values: &[ + &["behaviour"], + &["behavior"], &["behavior"], &["behaviors"], &["behaviour"], @@ -83350,6 +157939,9 @@ pub static WORD_BEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["behavioral"], &["behavioral"], &["behaviors"], + &["behaviour", "behaviours"], + &["behaviour"], + &["behavior"], &["behavior"], &["behavioral"], &["behaviors"], @@ -83358,12 +157950,17 @@ pub static WORD_BEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["behavioral"], &["behaviour"], &["behavioural"], + &["behaviour"], + &["behaviours"], + &["behind"], + &["behind", "being"], &["benghazi"], &["bethesda"], &["behaviour"], &["behaviours"], + &["behaviour"], ], - range: 5..=8, + range: 3..=8, }; static WORD_BEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83376,41 +157973,63 @@ pub static WORD_BEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("iinning"), + dictgen::InsensitiveStr::Ascii("iner"), + dictgen::InsensitiveStr::Ascii("ines"), dictgen::InsensitiveStr::Ascii("ining"), 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"], + &["begin", "begging"], &["beginner"], &["beginners"], - &["begging"], + &["beginning"], + &["beginning"], + &["begging", "beginning"], &["beginning"], &["beginnings"], &["begging"], + &["beginning"], + &["beginning"], + &["begins"], + &["beginning"], + &["beginner"], &["begins"], &["beginning"], &["beginning"], &["beginnings"], + &["begin"], + &["beginning"], &["beginning"], &["beginnings"], &["beginnings"], + &["beginning"], + &["beginnings"], &["belgian"], &["belgium"], &["bengals"], ], - range: 3..=7, + range: 3..=8, }; static WORD_BEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83420,13 +158039,32 @@ static WORD_BEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["befriend"], &["before"], &["befriend"], &["befriend"]], - range: 3..=5, + 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 { @@ -83438,9 +158076,19 @@ pub static WORD_BEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("htoven"), dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ings"), dictgen::InsensitiveStr::Ascii("thoveen"), + dictgen::InsensitiveStr::Ascii("tween"), + dictgen::InsensitiveStr::Ascii("twen"), + ], + values: &[ + &["beethoven"], + &["being", "been"], + &["beings"], + &["beethoven"], + &["between"], + &["between"], ], - values: &[&["beethoven"], &["being"], &["beethoven"]], range: 3..=7, }; @@ -83450,8 +158098,11 @@ static WORD_BED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("ore")], - values: &[&["before"]], + keys: &[ + dictgen::InsensitiveStr::Ascii("ing"), + dictgen::InsensitiveStr::Ascii("ore"), + ], + values: &[&["bedding", "begging"], &["before"]], range: 3..=3, }; @@ -83462,34 +158113,97 @@ static WORD_BEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("uasse"), dictgen::InsensitiveStr::Ascii("usae"), + dictgen::InsensitiveStr::Ascii("use"), + dictgen::InsensitiveStr::Ascii("xause"), ], values: &[ + &["because"], + &["because"], + &["because"], &["became"], - &["becomes"], + &["becomes", "became"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], + &["because"], &["because"], &["because"], &["benchmark"], + &["benchmarked"], + &["benchmarking"], &["benchmarks"], + &["benchmark"], + &["benchmarks"], + &["become"], &["becoming"], &["becoming"], + &["becomes"], + &["because"], + &["because"], + &["vector"], + &["vectors"], + &["because"], &["because"], &["because"], &["because"], &["because"], ], - range: 4..=7, + 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("ongs")], + values: &[&["belongs"]], + range: 4..=4, }; static WORD_BEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83499,13 +158213,17 @@ static WORD_BEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("hviour"), dictgen::InsensitiveStr::Ascii("hviours"), dictgen::InsensitiveStr::Ascii("ltes"), + dictgen::InsensitiveStr::Ascii("on"), dictgen::InsensitiveStr::Ascii("rdude"), + dictgen::InsensitiveStr::Ascii("rword"), dictgen::InsensitiveStr::Ascii("slty"), dictgen::InsensitiveStr::Ascii("stiality"), dictgen::InsensitiveStr::Ascii("stley"), @@ -83513,23 +158231,33 @@ pub static WORD_BEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tiful"), dictgen::InsensitiveStr::Ascii("ucop"), dictgen::InsensitiveStr::Ascii("uitful"), + dictgen::InsensitiveStr::Ascii("uracracy"), dictgen::InsensitiveStr::Ascii("urocracy"), dictgen::InsensitiveStr::Ascii("urocratic"), + dictgen::InsensitiveStr::Ascii("use"), + dictgen::InsensitiveStr::Ascii("uti"), 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("viour"), ], values: &[ + &["beacon"], + &["because"], &["beachhead"], &["beaucoup"], &["because"], &["behaviour"], &["behaviours"], &["beatles"], + &["beacon"], &["bearded"], + &["bareword"], &["beastly"], &["bestiality"], &["beastly"], @@ -83538,15 +158266,21 @@ pub static WORD_BEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["beaucoup"], &["beautiful"], &["bureaucracy"], + &["bureaucracy"], &["bureaucratic"], + &["because"], + &["beauty"], &["beautifully"], &["beautifully"], &["beautifully"], &["beautifully"], + &["beauty"], + &["beautified"], &["beautiful"], &["beautifully"], + &["behaviour"], ], - range: 4..=9, + range: 2..=9, }; static WORD_BC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83557,15 +158291,30 @@ static WORD_BC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"]], + 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("oolean"), + dictgen::InsensitiveStr::Ascii("ooleans"), + ], + values: &[&["boolean"], &["booleans"]], + range: 6..=7, +}; + static WORD_BA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Nested(&WORD_BA_CHILDREN), - value: None, + value: Some(&["by", "be"]), }; static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ @@ -83575,8 +158324,8 @@ static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_BAD_NODE), None, None, - None, - None, + Some(&WORD_BAG_NODE), + Some(&WORD_BAH_NODE), Some(&WORD_BAI_NODE), None, Some(&WORD_BAK_NODE), @@ -83620,6 +158369,8 @@ static WORD_BAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_BAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("eries"), + dictgen::InsensitiveStr::Ascii("ery"), dictgen::InsensitiveStr::Ascii("hrom"), dictgen::InsensitiveStr::Ascii("hrooom"), dictgen::InsensitiveStr::Ascii("istia"), @@ -83628,6 +158379,8 @@ pub static WORD_BAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -83650,6 +158403,8 @@ pub static WORD_BAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("tlestsr"), ], values: &[ + &["batteries"], + &["battery"], &["bathroom"], &["bathroom"], &["batista"], @@ -83658,6 +158413,8 @@ pub static WORD_BAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["batista"], &["battalion"], &["battalion"], + &["batteries"], + &["battery"], &["battlefield"], &["battlefront"], &["battleship"], @@ -83679,7 +158436,7 @@ pub static WORD_BAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["battleship"], &["battlestar"], ], - range: 4..=8, + range: 3..=8, }; static WORD_BAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83689,18 +158446,25 @@ static WORD_BAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("nhee"), + dictgen::InsensitiveStr::Ascii("sic"), + dictgen::InsensitiveStr::Ascii("sically"), dictgen::InsensitiveStr::Ascii("tane"), dictgen::InsensitiveStr::Ascii("tardes"), dictgen::InsensitiveStr::Ascii("tardos"), @@ -83708,11 +158472,26 @@ pub static WORD_BAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -83722,6 +158501,8 @@ pub static WORD_BAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bastion"], &["basketball"], &["banshee"], + &["basic"], + &["basically"], &["bastante"], &["bastards"], &["bastards"], @@ -83729,8 +158510,18 @@ pub static WORD_BAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bastards"], &["bastards"], &["bastion"], + &["abstract"], + &["abstracted"], + &["abstracter"], + &["abstracting"], + &["abstraction"], + &["abstractions"], + &["abstractly"], + &["abstractness"], + &["abstractor"], + &["abstracts"], ], - range: 4..=7, + range: 1..=9, }; static WORD_BAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83751,6 +158542,7 @@ pub static WORD_BAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("celoneta"), @@ -83762,17 +158554,27 @@ pub static WORD_BAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("gani"), dictgen::InsensitiveStr::Ascii("gian"), dictgen::InsensitiveStr::Ascii("gianing"), + 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("rackus"), dictgen::InsensitiveStr::Ascii("racs"), dictgen::InsensitiveStr::Ascii("rakcs"), dictgen::InsensitiveStr::Ascii("rells"), + 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"], @@ -83786,6 +158588,7 @@ pub static WORD_BAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["barbarians"], &["barbarians"], &["barbaric"], + &["barbados"], &["barbarians"], &["bracelets"], &["barcelona"], @@ -83797,19 +158600,29 @@ pub static WORD_BAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bargain"], &["bargain"], &["bargaining"], + &["barrier"], &["brainer"], &["barista"], &["barkley"], + &["branch"], + &["branched"], + &["brancher"], + &["branchers"], + &["branches"], + &["branching"], &["barracks"], &["barracks"], &["barracks"], &["barrels"], + &["barriers"], &["barrels"], + &["barriers"], &["barista"], &["bartenders"], &["bravery"], + &["barycentric"], ], - range: 4..=8, + range: 3..=8, }; static WORD_BAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83838,7 +158651,7 @@ pub static WORD_BAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ut"), dictgen::InsensitiveStr::Ascii("ynet"), ], - values: &[&["boardwalk"], &["about"], &["bayonet"]], + values: &[&["boardwalk"], &["about", "bout"], &["bayonet"]], range: 2..=6, }; @@ -83850,11 +158663,15 @@ static WORD_BAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("dwidht"), + dictgen::InsensitiveStr::Ascii("dwidthm"), dictgen::InsensitiveStr::Ascii("dwitdh"), dictgen::InsensitiveStr::Ascii("dwith"), dictgen::InsensitiveStr::Ascii("galdesh"), @@ -83872,10 +158689,14 @@ pub static WORD_BAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("kruptsy"), dictgen::InsensitiveStr::Ascii("krupty"), dictgen::InsensitiveStr::Ascii("krutpcy"), + dictgen::InsensitiveStr::Ascii("lance"), dictgen::InsensitiveStr::Ascii("ruptcy"), ], values: &[ &["bananas"], + &["branch", "bench"], + &["branched", "benched"], + &["branches", "benches"], &["bandits"], &["bandwidth"], &["bandwagon"], @@ -83883,6 +158704,7 @@ pub static WORD_BAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bandwidth"], &["bandwidth"], &["bandwidth"], + &["bandwidth"], &["bangladesh"], &["bangladesh"], &["bangkok"], @@ -83898,9 +158720,10 @@ pub static WORD_BAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["bankruptcy"], &["bankruptcy"], &["bankruptcy"], + &["balance"], &["bankruptcy"], ], - range: 4..=8, + range: 2..=8, }; static WORD_BAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83910,10 +158733,12 @@ static WORD_BAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("canes"), + dictgen::InsensitiveStr::Ascii("ck"), dictgen::InsensitiveStr::Ascii("ckberry"), dictgen::InsensitiveStr::Ascii("cked"), dictgen::InsensitiveStr::Ascii("ckhawks"), @@ -83922,18 +158747,24 @@ pub static WORD_BAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("cksmith"), dictgen::InsensitiveStr::Ascii("coney"), dictgen::InsensitiveStr::Ascii("conny"), + dictgen::InsensitiveStr::Ascii("ence"), dictgen::InsensitiveStr::Ascii("itmore"), dictgen::InsensitiveStr::Ascii("lisitc"), dictgen::InsensitiveStr::Ascii("listc"), dictgen::InsensitiveStr::Ascii("lsitic"), dictgen::InsensitiveStr::Ascii("naced"), + dictgen::InsensitiveStr::Ascii("oon"), + dictgen::InsensitiveStr::Ascii("oons"), + dictgen::InsensitiveStr::Ascii("se"), dictgen::InsensitiveStr::Ascii("sphemy"), ], values: &[ + &["balancing"], &["balanced"], &["balanced"], &["balances"], &["balances"], + &["black", "balk"], &["blackberry"], &["blacked"], &["blackhawks"], @@ -83942,14 +158773,18 @@ pub static WORD_BAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["blacksmith"], &["balcony"], &["balcony"], + &["balance"], &["baltimore"], &["ballistic"], &["ballistic"], &["ballistic"], &["balanced"], + &["balloon"], + &["balloons"], + &["false"], &["blasphemy"], ], - range: 4..=7, + range: 2..=7, }; static WORD_BAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83961,9 +158796,27 @@ pub static WORD_BAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("c"), dictgen::InsensitiveStr::Ascii("cers"), + dictgen::InsensitiveStr::Ascii("crefs"), + dictgen::InsensitiveStr::Ascii("end"), + dictgen::InsensitiveStr::Ascii("ends"), 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"], + &["basketball"], + &["backup"], + &["backups"], + &["backward"], + &["backwards"], ], - values: &[&["back"], &["backers"], &["basketball"]], range: 1..=7, }; @@ -83973,9 +158826,47 @@ static WORD_BAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_BAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("scly")], - values: &[&["basically"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("sc"), + dictgen::InsensitiveStr::Ascii("scly"), + dictgen::InsensitiveStr::Ascii("sed"), + ], + values: &[&["basic"], &["basically"], &["raised"]], + 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")], + values: &[&["bag"]], + range: 1..=1, }; static WORD_BAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -83994,62 +158885,155 @@ pub static WORD_BAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_BAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_BAC_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_BAC_CHILDREN), value: None, }; -pub static WORD_BAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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, + None, + None, + None, + None, +]; + +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::Flat(&WORD_BACK_CHILDREN), + value: None, +}; + +pub static WORD_BACK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("eause"), - dictgen::InsensitiveStr::Ascii("ehlor"), - dictgen::InsensitiveStr::Ascii("ehlors"), - dictgen::InsensitiveStr::Ascii("helores"), - dictgen::InsensitiveStr::Ascii("helour"), - dictgen::InsensitiveStr::Ascii("hleor"), - dictgen::InsensitiveStr::Ascii("hleors"), - dictgen::InsensitiveStr::Ascii("holer"), - dictgen::InsensitiveStr::Ascii("holers"), - dictgen::InsensitiveStr::Ascii("kbacking"), - dictgen::InsensitiveStr::Ascii("kdooor"), - dictgen::InsensitiveStr::Ascii("kdor"), - dictgen::InsensitiveStr::Ascii("keast"), - dictgen::InsensitiveStr::Ascii("kerds"), - dictgen::InsensitiveStr::Ascii("kfeild"), - dictgen::InsensitiveStr::Ascii("kfied"), - dictgen::InsensitiveStr::Ascii("kfiled"), - dictgen::InsensitiveStr::Ascii("kgorund"), - dictgen::InsensitiveStr::Ascii("kgorunds"), - dictgen::InsensitiveStr::Ascii("kgroud"), - dictgen::InsensitiveStr::Ascii("kgroudn"), - dictgen::InsensitiveStr::Ascii("kgrouds"), - dictgen::InsensitiveStr::Ascii("kgrouns"), - dictgen::InsensitiveStr::Ascii("kgruond"), - dictgen::InsensitiveStr::Ascii("khacking"), - dictgen::InsensitiveStr::Ascii("kjacking"), - dictgen::InsensitiveStr::Ascii("kpacing"), - dictgen::InsensitiveStr::Ascii("kpackng"), - dictgen::InsensitiveStr::Ascii("kpacs"), - dictgen::InsensitiveStr::Ascii("kpakcs"), - dictgen::InsensitiveStr::Ascii("krgound"), - dictgen::InsensitiveStr::Ascii("krounds"), - dictgen::InsensitiveStr::Ascii("ksta"), - dictgen::InsensitiveStr::Ascii("ktacking"), - dictgen::InsensitiveStr::Ascii("lony"), + dictgen::InsensitiveStr::Ascii("ards"), + dictgen::InsensitiveStr::Ascii("backing"), + dictgen::InsensitiveStr::Ascii("bround"), + dictgen::InsensitiveStr::Ascii("brounds"), + dictgen::InsensitiveStr::Ascii("dooor"), + dictgen::InsensitiveStr::Ascii("dor"), + dictgen::InsensitiveStr::Ascii("east"), + dictgen::InsensitiveStr::Ascii("edn"), + dictgen::InsensitiveStr::Ascii("edns"), + dictgen::InsensitiveStr::Ascii("ened"), + dictgen::InsensitiveStr::Ascii("eneds"), + dictgen::InsensitiveStr::Ascii("erds"), + dictgen::InsensitiveStr::Ascii("feild"), + dictgen::InsensitiveStr::Ascii("fied"), + dictgen::InsensitiveStr::Ascii("filed"), + dictgen::InsensitiveStr::Ascii("gorund"), + dictgen::InsensitiveStr::Ascii("gorunds"), + dictgen::InsensitiveStr::Ascii("gound"), + dictgen::InsensitiveStr::Ascii("gounds"), + dictgen::InsensitiveStr::Ascii("gournd"), + dictgen::InsensitiveStr::Ascii("gournds"), + dictgen::InsensitiveStr::Ascii("grond"), + dictgen::InsensitiveStr::Ascii("gronds"), + dictgen::InsensitiveStr::Ascii("groud"), + dictgen::InsensitiveStr::Ascii("groudn"), + dictgen::InsensitiveStr::Ascii("grouds"), + dictgen::InsensitiveStr::Ascii("groung"), + dictgen::InsensitiveStr::Ascii("groungs"), + dictgen::InsensitiveStr::Ascii("grouns"), + dictgen::InsensitiveStr::Ascii("grount"), + dictgen::InsensitiveStr::Ascii("grounts"), + dictgen::InsensitiveStr::Ascii("grund"), + dictgen::InsensitiveStr::Ascii("grunds"), + dictgen::InsensitiveStr::Ascii("gruond"), + dictgen::InsensitiveStr::Ascii("hacking"), + dictgen::InsensitiveStr::Ascii("jacking"), + dictgen::InsensitiveStr::Ascii("lght"), + dictgen::InsensitiveStr::Ascii("lghting"), + dictgen::InsensitiveStr::Ascii("lghts"), + dictgen::InsensitiveStr::Ascii("ned"), + dictgen::InsensitiveStr::Ascii("neds"), + dictgen::InsensitiveStr::Ascii("ound"), + dictgen::InsensitiveStr::Ascii("ounds"), + dictgen::InsensitiveStr::Ascii("pacing"), + dictgen::InsensitiveStr::Ascii("packng"), + dictgen::InsensitiveStr::Ascii("pacs"), + dictgen::InsensitiveStr::Ascii("pakcs"), + dictgen::InsensitiveStr::Ascii("psace"), + dictgen::InsensitiveStr::Ascii("refence"), + dictgen::InsensitiveStr::Ascii("rgound"), + dictgen::InsensitiveStr::Ascii("round"), + dictgen::InsensitiveStr::Ascii("rounds"), + dictgen::InsensitiveStr::Ascii("sapce"), + dictgen::InsensitiveStr::Ascii("slase"), + dictgen::InsensitiveStr::Ascii("slases"), + dictgen::InsensitiveStr::Ascii("slashs"), + dictgen::InsensitiveStr::Ascii("sta"), + dictgen::InsensitiveStr::Ascii("tacking"), + dictgen::InsensitiveStr::Ascii("wad"), + dictgen::InsensitiveStr::Ascii("wardss"), + dictgen::InsensitiveStr::Ascii("ware"), + dictgen::InsensitiveStr::Ascii("wark"), + dictgen::InsensitiveStr::Ascii("wrad"), ], values: &[ - &["because"], - &["bachelor"], - &["bachelors"], - &["bachelors"], - &["bachelor"], - &["bachelor"], - &["bachelors"], - &["bachelor"], - &["bachelors"], + &["backwards"], &["backpacking"], + &["background"], + &["backgrounds"], &["backdoor"], &["backdoor"], &["backseat"], + &["backend"], + &["backends"], + &["backend", "blackened"], + &["backends", "blackens"], &["backers"], &["backfield"], &["backfield"], @@ -84058,22 +159042,125 @@ pub static WORD_BAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["backgrounds"], &["background"], &["backgrounds"], + &["background"], &["backgrounds"], + &["background"], + &["backgrounds"], + &["background"], + &["backgrounds"], + &["backgrounds"], + &["background"], + &["backgrounds"], + &["backgrounds"], + &["background"], + &["backgrounds"], + &["background"], &["backgrounds"], &["backgrounds"], &["backpacking"], &["backpacking"], + &["backlight"], + &["backlighting"], + &["backlights"], + &["backend"], + &["backends"], + &["background"], + &["backgrounds"], &["backpacking"], &["backpacking"], &["backpacks"], &["backpacks"], + &["backspace"], + &["backreference"], &["backgrounds"], + &["background"], &["backgrounds"], + &["backspace"], + &["backslash"], + &["backslashes"], + &["backslashes"], &["backseat"], &["backpacking"], - &["balcony"], + &["backward"], + &["backwards"], + &["backward"], + &["backward"], + &["backward"], ], - range: 4..=8, + range: 3..=7, +}; + +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("oler"), + dictgen::InsensitiveStr::Ascii("olers"), + ], + values: &[ + &["bachelors"], + &["bachelor"], + &["bachelor"], + &["bachelors"], + &["bachelor"], + &["bachelors"], + ], + range: 4..=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 { @@ -84083,6 +159170,7 @@ static WORD_BAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -84092,6 +159180,7 @@ pub static WORD_BAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ysittting"), ], values: &[ + &["babel", "table", "bible"], &["babylon"], &["babysitter"], &["babysitter"], @@ -84100,7 +159189,7 @@ pub static WORD_BAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["babysitter"], &["babysitting"], ], - range: 4..=9, + range: 2..=9, }; static WORD_A_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -84109,7 +159198,7 @@ static WORD_A_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::Di }; static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_AA_NODE), Some(&WORD_AB_NODE), Some(&WORD_AC_NODE), Some(&WORD_AD_NODE), @@ -84123,7 +159212,7 @@ static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_AL_NODE), Some(&WORD_AM_NODE), Some(&WORD_AN_NODE), - None, + Some(&WORD_AO_NODE), Some(&WORD_AP_NODE), Some(&WORD_AQ_NODE), Some(&WORD_AR_NODE), @@ -84132,11 +159221,41 @@ static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>> Some(&WORD_AU_NODE), Some(&WORD_AV_NODE), Some(&WORD_AW_NODE), - None, - None, + Some(&WORD_AX_NODE), + Some(&WORD_AY_NODE), None, ]; +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("snc"), + dictgen::InsensitiveStr::Ascii("way"), + dictgen::InsensitiveStr::Ascii("ways"), + ], + values: &[&["async"], &["anyway", "away"], &["always"]], + range: 3..=4, +}; + +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("ix"), + dictgen::InsensitiveStr::Ascii("pressed"), + ], + values: &[&["axes"], &["axis"], &["expressed"]], + range: 2..=7, +}; + static WORD_AW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_AW_CHILDREN), value: None, @@ -84147,6 +159266,9 @@ pub static WORD_AW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -84163,14 +159285,23 @@ pub static WORD_AW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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("some"), dictgen::InsensitiveStr::Ascii("ya"), ], values: &[ &["awakened"], &["awakened"], &["awarded"], + &["always", "away"], + &["awful"], + &["awfully"], &["weakened"], &["awesomely"], &["awesomely"], @@ -84187,96 +159318,524 @@ pub static WORD_AW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["awkwardness"], &["awkwardness"], &["awkwardly"], + &["awning"], + &["awnings"], + &["answer"], &["answered"], &["answering"], + &["answers"], + &["avoid"], + &["awesome"], &["away"], ], range: 2..=13, }; static WORD_AV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_AV_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_AV_CHILDREN), value: None, }; -pub static WORD_AV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("acodos"), - dictgen::InsensitiveStr::Ascii("aiable"), - dictgen::InsensitiveStr::Ascii("aialble"), - dictgen::InsensitiveStr::Ascii("ailabale"), - dictgen::InsensitiveStr::Ascii("ailabe"), - dictgen::InsensitiveStr::Ascii("ailabiliy"), - dictgen::InsensitiveStr::Ascii("ailabillity"), - dictgen::InsensitiveStr::Ascii("ailabilty"), - dictgen::InsensitiveStr::Ascii("ailablity"), - dictgen::InsensitiveStr::Ascii("ailaible"), - dictgen::InsensitiveStr::Ascii("ailble"), - dictgen::InsensitiveStr::Ascii("ailiable"), - dictgen::InsensitiveStr::Ascii("ailible"), - dictgen::InsensitiveStr::Ascii("aition"), - dictgen::InsensitiveStr::Ascii("alable"), - dictgen::InsensitiveStr::Ascii("alaible"), - dictgen::InsensitiveStr::Ascii("alance"), - dictgen::InsensitiveStr::Ascii("aliability"), - dictgen::InsensitiveStr::Ascii("aliable"), - dictgen::InsensitiveStr::Ascii("ataras"), - dictgen::InsensitiveStr::Ascii("atards"), - dictgen::InsensitiveStr::Ascii("atares"), - dictgen::InsensitiveStr::Ascii("ation"), - dictgen::InsensitiveStr::Ascii("eradge"), - dictgen::InsensitiveStr::Ascii("erageadi"), - dictgen::InsensitiveStr::Ascii("erageed"), - dictgen::InsensitiveStr::Ascii("erageifs"), - dictgen::InsensitiveStr::Ascii("ergaed"), - dictgen::InsensitiveStr::Ascii("ergaes"), - dictgen::InsensitiveStr::Ascii("iaiton"), - dictgen::InsensitiveStr::Ascii("ialability"), - dictgen::InsensitiveStr::Ascii("ialable"), - dictgen::InsensitiveStr::Ascii("ilable"), - dictgen::InsensitiveStr::Ascii("negers"), - dictgen::InsensitiveStr::Ascii("odacos"), - dictgen::InsensitiveStr::Ascii("taars"), + 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("inding"), ], values: &[ + &["avoid"], &["avocados"], - &["available"], - &["available"], - &["available"], - &["available"], - &["availability"], - &["availability"], - &["availability"], - &["availability"], - &["available"], - &["available"], - &["available"], + &["avoided"], + &["avoiding"], + &["avoids"], + &["avoidance"], + &["avoiding"], + ], + 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("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"], + &["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("ege"), + dictgen::InsensitiveStr::Ascii("y"), + ], + values: &[ + &["average"], + &["averaging"], + &["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"], - &["avatars"], - &["avatars"], - &["avatars"], - &["aviation"], - &["averaged"], - &["averaged"], - &["averaged"], - &["averages"], - &["averaged"], - &["averages"], - &["aviation"], + &["available"], + &["available"], + &["available"], + &["evaluate"], + &["evaluated"], + &["evaluates"], + &["evaluating"], + ], + range: 4..=8, +}; + +static WORD_AVAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_AVAI_CHILDREN), + value: None, +}; + +pub static WORD_AVAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("able"), + dictgen::InsensitiveStr::Ascii("alable"), + dictgen::InsensitiveStr::Ascii("albale"), + dictgen::InsensitiveStr::Ascii("albe"), + dictgen::InsensitiveStr::Ascii("albel"), + dictgen::InsensitiveStr::Ascii("albility"), + dictgen::InsensitiveStr::Ascii("alble"), + dictgen::InsensitiveStr::Ascii("blable"), + dictgen::InsensitiveStr::Ascii("ble"), + dictgen::InsensitiveStr::Ascii("iability"), + dictgen::InsensitiveStr::Ascii("iable"), + dictgen::InsensitiveStr::Ascii("ibility"), + dictgen::InsensitiveStr::Ascii("ible"), + dictgen::InsensitiveStr::Ascii("ilable"), + dictgen::InsensitiveStr::Ascii("laable"), + dictgen::InsensitiveStr::Ascii("labable"), + dictgen::InsensitiveStr::Ascii("labal"), + dictgen::InsensitiveStr::Ascii("labale"), + dictgen::InsensitiveStr::Ascii("labality"), + dictgen::InsensitiveStr::Ascii("labble"), + dictgen::InsensitiveStr::Ascii("labe"), + dictgen::InsensitiveStr::Ascii("labed"), + dictgen::InsensitiveStr::Ascii("label"), + dictgen::InsensitiveStr::Ascii("labele"), + dictgen::InsensitiveStr::Ascii("labelity"), + dictgen::InsensitiveStr::Ascii("labiliy"), + dictgen::InsensitiveStr::Ascii("labillity"), + dictgen::InsensitiveStr::Ascii("labilty"), + dictgen::InsensitiveStr::Ascii("labke"), + dictgen::InsensitiveStr::Ascii("labl"), + dictgen::InsensitiveStr::Ascii("labled"), + dictgen::InsensitiveStr::Ascii("lablen"), + dictgen::InsensitiveStr::Ascii("lablity"), + dictgen::InsensitiveStr::Ascii("labyl"), + dictgen::InsensitiveStr::Ascii("laiable"), + dictgen::InsensitiveStr::Ascii("laible"), + dictgen::InsensitiveStr::Ascii("lailability"), + dictgen::InsensitiveStr::Ascii("laility"), + dictgen::InsensitiveStr::Ascii("lalable"), + dictgen::InsensitiveStr::Ascii("lalbe"), + dictgen::InsensitiveStr::Ascii("lalble"), + dictgen::InsensitiveStr::Ascii("lale"), + dictgen::InsensitiveStr::Ascii("laliable"), + dictgen::InsensitiveStr::Ascii("lality"), + dictgen::InsensitiveStr::Ascii("lanle"), + dictgen::InsensitiveStr::Ascii("lavble"), + dictgen::InsensitiveStr::Ascii("lavility"), + dictgen::InsensitiveStr::Ascii("lavle"), + dictgen::InsensitiveStr::Ascii("lbale"), + dictgen::InsensitiveStr::Ascii("lbe"), + dictgen::InsensitiveStr::Ascii("lble"), + dictgen::InsensitiveStr::Ascii("leable"), + dictgen::InsensitiveStr::Ascii("leble"), + dictgen::InsensitiveStr::Ascii("liable"), + dictgen::InsensitiveStr::Ascii("libility"), + dictgen::InsensitiveStr::Ascii("libilty"), + dictgen::InsensitiveStr::Ascii("lible"), + dictgen::InsensitiveStr::Ascii("llable"), + dictgen::InsensitiveStr::Ascii("tion"), + ], + values: &[ + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], &["availability"], &["available"], &["available"], - &["avengers"], - &["avocados"], - &["avatars"], + &["available"], + &["availability"], + &["available"], + &["availability"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["availability"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["availability"], + &["availability"], + &["availability"], + &["availability"], + &["available"], + &["available"], + &["available"], + &["available"], + &["availability"], + &["available"], + &["available"], + &["available"], + &["availability"], + &["availability"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["availability"], + &["available"], + &["available"], + &["availability"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["available"], + &["availability"], + &["availability"], + &["available"], + &["available"], + &["aviation"], ], - range: 5..=11, + range: 3..=11, +}; + +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("odos")], + values: &[&["avocados"]], + range: 4..=4, }; static WORD_AU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -84291,14 +159850,14 @@ static WORD_AU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_AUD_NODE), None, None, - None, + Some(&WORD_AUG_NODE), Some(&WORD_AUH_NODE), Some(&WORD_AUI_NODE), None, None, None, None, - None, + Some(&WORD_AUN_NODE), Some(&WORD_AUO_NODE), None, None, @@ -84320,11 +159879,20 @@ static WORD_AUX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], @@ -84332,6 +159900,15 @@ pub static WORD_AUX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["auxiliary"], &["auxiliaries"], &["auxiliary"], + &["auxiliary"], + &["auxiliaries"], + &["auxiliary"], + &["auxiliaries"], + &["auxiliary"], + &["auxiliaries"], + &["auxiliary"], + &["auxiliary"], + &["auxiliary"], ], range: 5..=9, }; @@ -84342,11 +159919,11 @@ static WORD_AUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_AUTA_NODE), None, None, None, - None, - None, + Some(&WORD_AUTE_NODE), None, None, Some(&WORD_AUTH_NODE), @@ -84354,7 +159931,7 @@ static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, None, None, - None, + Some(&WORD_AUTM_NODE), None, Some(&WORD_AUTO_NODE), None, @@ -84362,7 +159939,7 @@ static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_AUTS_NODE), Some(&WORD_AUTT_NODE), - None, + Some(&WORD_AUTU_NODE), None, None, None, @@ -84370,6 +159947,17 @@ static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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, @@ -84393,88 +159981,294 @@ pub static WORD_AUTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic }; static WORD_AUTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_AUTO_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_AUTO_CHILDREN), value: None, }; -pub static WORD_AUTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_AUTO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_AUTOA_NODE), + None, + Some(&WORD_AUTOC_NODE), + None, + 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), + None, + Some(&WORD_AUTOM_NODE), + Some(&WORD_AUTON_NODE), + None, + Some(&WORD_AUTOP_NODE), + None, + Some(&WORD_AUTOR_NODE), + Some(&WORD_AUTOS_NODE), + None, + None, + None, + None, + None, + None, + None, +]; + +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("attak"), - dictgen::InsensitiveStr::Ascii("attaks"), - dictgen::InsensitiveStr::Ascii("attk"), - dictgen::InsensitiveStr::Ascii("atttack"), - dictgen::InsensitiveStr::Ascii("chtonous"), - dictgen::InsensitiveStr::Ascii("corect"), - dictgen::InsensitiveStr::Ascii("coreect"), - dictgen::InsensitiveStr::Ascii("corrct"), - dictgen::InsensitiveStr::Ascii("correkt"), - dictgen::InsensitiveStr::Ascii("corrent"), - dictgen::InsensitiveStr::Ascii("corret"), - dictgen::InsensitiveStr::Ascii("corrext"), - dictgen::InsensitiveStr::Ascii("corrrect"), - dictgen::InsensitiveStr::Ascii("ctonous"), - dictgen::InsensitiveStr::Ascii("grah"), - dictgen::InsensitiveStr::Ascii("grapgh"), - dictgen::InsensitiveStr::Ascii("grpah"), - dictgen::InsensitiveStr::Ascii("korrect"), - dictgen::InsensitiveStr::Ascii("matice"), - dictgen::InsensitiveStr::Ascii("maticly"), - dictgen::InsensitiveStr::Ascii("matico"), - dictgen::InsensitiveStr::Ascii("matied"), - dictgen::InsensitiveStr::Ascii("matiek"), - dictgen::InsensitiveStr::Ascii("mato"), - dictgen::InsensitiveStr::Ascii("matonic"), - dictgen::InsensitiveStr::Ascii("matron"), - dictgen::InsensitiveStr::Ascii("matted"), - dictgen::InsensitiveStr::Ascii("mibile"), - dictgen::InsensitiveStr::Ascii("mitive"), - dictgen::InsensitiveStr::Ascii("mobilies"), - dictgen::InsensitiveStr::Ascii("moblie"), - dictgen::InsensitiveStr::Ascii("moblies"), - dictgen::InsensitiveStr::Ascii("moderador"), - dictgen::InsensitiveStr::Ascii("moderater"), - dictgen::InsensitiveStr::Ascii("modertor"), - dictgen::InsensitiveStr::Ascii("modorator"), - dictgen::InsensitiveStr::Ascii("momous"), - dictgen::InsensitiveStr::Ascii("monomous"), - dictgen::InsensitiveStr::Ascii("monous"), - dictgen::InsensitiveStr::Ascii("mony"), - dictgen::InsensitiveStr::Ascii("moterator"), - dictgen::InsensitiveStr::Ascii("motice"), - dictgen::InsensitiveStr::Ascii("motion"), - dictgen::InsensitiveStr::Ascii("motize"), - dictgen::InsensitiveStr::Ascii("motove"), - dictgen::InsensitiveStr::Ascii("namous"), - dictgen::InsensitiveStr::Ascii("nation"), - dictgen::InsensitiveStr::Ascii("nimous"), - dictgen::InsensitiveStr::Ascii("nomity"), - dictgen::InsensitiveStr::Ascii("nomos"), - dictgen::InsensitiveStr::Ascii("nonous"), - dictgen::InsensitiveStr::Ascii("r"), - dictgen::InsensitiveStr::Ascii("ritharian"), - dictgen::InsensitiveStr::Ascii("rity"), + dictgen::InsensitiveStr::Ascii("ae"), + dictgen::InsensitiveStr::Ascii("avegs"), + dictgen::InsensitiveStr::Ascii("aveperodical"), + dictgen::InsensitiveStr::Ascii("ence"), ], values: &[ - &["autoattack"], - &["autoattack"], - &["autoattack"], - &["autoattack"], - &["autochthonous"], - &["autocorrect"], - &["autocorrect"], - &["autocorrect"], - &["autocorrect"], - &["autocorrect"], - &["autocorrect"], - &["autocorrect"], - &["autocorrect"], - &["autochthonous"], - &["autograph"], - &["autograph"], - &["autograph"], - &["autocorrect"], + &["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_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("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("etic"), + dictgen::InsensitiveStr::Ascii("etically"), + dictgen::InsensitiveStr::Ascii("ibile"), + 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("tically"), + ], + values: &[ + &["automatically"], + &["automagically"], + &["automatic"], + &["automatically"], + &["automanufactured"], + &["automatically"], + &["automatically"], + &["automatically", "automatic", "automated"], + &["automatically", "automatic"], + &["automatically"], + &["automatically"], + &["automatically"], + &["automatically"], &["automate"], &["automatically"], + &["automatically"], &["automation"], &["automate"], &["automate"], @@ -84482,6 +160276,8 @@ pub static WORD_AUTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["automation"], &["automation"], &["automate"], + &["automatic"], + &["automatically"], &["automobile"], &["automotive"], &["automobile"], @@ -84500,17 +160296,177 @@ pub static WORD_AUTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["automation"], &["automotive"], &["automotive"], - &["autonomous"], - &["automation"], - &["autonomous"], - &["autonomy"], - &["autonomous"], - &["autonomous"], - &["author"], - &["authoritarian"], - &["authority"], + &["automatically"], ], - range: 1..=9, + range: 3..=11, +}; + +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_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("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("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"], + &["autocommitting"], + &["autocomplete"], + &["autocompleted"], + &["autocompletes"], + &["autocompleting"], + &["autocompletion"], + &["autocommit"], + &["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("ttak"), + dictgen::InsensitiveStr::Ascii("ttaks"), + dictgen::InsensitiveStr::Ascii("ttk"), + dictgen::InsensitiveStr::Ascii("tttack"), + ], + values: &[ + &["autoattack"], + &["autoattack"], + &["autoattack"], + &["autoattack"], + ], + range: 3..=6, +}; + +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 { @@ -84520,72 +160476,124 @@ static WORD_AUTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_AUTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("matic"), + dictgen::InsensitiveStr::Ascii("matically"), dictgen::InsensitiveStr::Ascii("sitc"), dictgen::InsensitiveStr::Ascii("stc"), dictgen::InsensitiveStr::Ascii("stisch"), ], - values: &[&["autistic"], &["autistic"], &["autistic"]], - range: 3..=6, + values: &[ + &["automatic"], + &["automatically"], + &["autistic"], + &["autistic"], + &["autistic"], + ], + range: 3..=9, }; static WORD_AUTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_AUTH_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_AUTH_CHILDREN), value: None, }; -pub static WORD_AUTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("enitcation"), - dictgen::InsensitiveStr::Ascii("enticaion"), - dictgen::InsensitiveStr::Ascii("enticaiton"), - dictgen::InsensitiveStr::Ascii("enticaton"), - dictgen::InsensitiveStr::Ascii("enticiy"), - dictgen::InsensitiveStr::Ascii("enticor"), - dictgen::InsensitiveStr::Ascii("enticty"), - dictgen::InsensitiveStr::Ascii("enticy"), - dictgen::InsensitiveStr::Ascii("entisity"), - dictgen::InsensitiveStr::Ascii("er"), - dictgen::InsensitiveStr::Ascii("erization"), - dictgen::InsensitiveStr::Ascii("erized"), - dictgen::InsensitiveStr::Ascii("obiographic"), - dictgen::InsensitiveStr::Ascii("obiography"), - dictgen::InsensitiveStr::Ascii("oratitive"), - dictgen::InsensitiveStr::Ascii("orative"), - dictgen::InsensitiveStr::Ascii("oritate"), - dictgen::InsensitiveStr::Ascii("oritatian"), - dictgen::InsensitiveStr::Ascii("oritation"), - dictgen::InsensitiveStr::Ascii("oritay"), - dictgen::InsensitiveStr::Ascii("orites"), - dictgen::InsensitiveStr::Ascii("orithies"), - dictgen::InsensitiveStr::Ascii("orithy"), - dictgen::InsensitiveStr::Ascii("oritiers"), - dictgen::InsensitiveStr::Ascii("orititive"), - dictgen::InsensitiveStr::Ascii("oritorian"), - dictgen::InsensitiveStr::Ascii("orizaton"), - dictgen::InsensitiveStr::Ascii("orotative"), - dictgen::InsensitiveStr::Ascii("oroties"), - dictgen::InsensitiveStr::Ascii("roity"), - dictgen::InsensitiveStr::Ascii("roization"), - dictgen::InsensitiveStr::Ascii("roized"), - dictgen::InsensitiveStr::Ascii("rorities"), + 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: &[ - &["authentication"], - &["authentication"], - &["authentication"], - &["authentication"], - &["authenticity"], - &["authenticator"], - &["authenticity"], - &["authenticity"], - &["authenticity"], - &["author"], + &["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("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("rizaton"), + dictgen::InsensitiveStr::Ascii("rizeed"), + dictgen::InsensitiveStr::Ascii("rotative"), + dictgen::InsensitiveStr::Ascii("roties"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[ &["autobiographic"], &["autobiography"], + &["author"], &["authoritative"], &["authoritative"], + &["authored"], &["authoritative"], &["authoritarian"], &["authorization"], @@ -84595,16 +160603,589 @@ pub static WORD_AUTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["authority"], &["authorities"], &["authoritative"], - &["authoritarian"], - &["authorization"], &["authoritative"], - &["authorities"], - &["authority"], + &["authoritarian"], &["authorization"], &["authorized"], + &["authoritative"], &["authorities"], + &["authors", "autos"], ], - range: 2..=11, + range: 1..=10, +}; + +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("cated"), + 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: &[ + &["authenticated"], + &["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"), + ], + values: &[ + &["authenticate"], + &["authenticated"], + &["authenticates"], + &["authenticating"], + &["authentication"], + ], + range: 7..=9, +}; + +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 { @@ -84614,6 +161195,7 @@ static WORD_AUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_AUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("sian"), dictgen::InsensitiveStr::Ascii("teriy"), dictgen::InsensitiveStr::Ascii("tira"), dictgen::InsensitiveStr::Ascii("tiran"), @@ -84641,6 +161223,7 @@ pub static WORD_AUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("trlaian"), ], values: &[ + &["gaussian", "russian", "austrian"], &["austerity"], &["austria"], &["austrian"], @@ -84665,7 +161248,7 @@ pub static WORD_AUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["australian"], &["austria"], &["austria"], - &["australians"], + &["australians", "australian"], ], range: 4..=10, }; @@ -84688,11 +161271,41 @@ static WORD_AUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["autoattack"], &["autocorrect"]], - range: 7..=8, + 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"), + ], + values: &[ + &["authenticate"], + &["authenticated"], + &["authenticates"], + &["authenticating"], + ], + range: 10..=12, }; static WORD_AUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -84715,9 +161328,27 @@ static WORD_AUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_AUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tenticate")], - values: &[&["authenticate"]], - range: 9..=9, + keys: &[ + dictgen::InsensitiveStr::Ascii("tenticate"), + dictgen::InsensitiveStr::Ascii("tor"), + dictgen::InsensitiveStr::Ascii("tors"), + ], + values: &[&["authenticate"], &["author"], &["authors"]], + range: 3..=9, +}; + +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("uest"), + dictgen::InsensitiveStr::Ascii("ument"), + ], + values: &[&["august"], &["argument", "augment"]], + range: 4..=5, }; static WORD_AUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -84731,6 +161362,7 @@ pub static WORD_AUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -84745,6 +161377,7 @@ pub static WORD_AUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["audible"], &["audacity"], &["audience"], + &["audience"], &["audible"], &["audiobook"], &["audiobooks"], @@ -84764,12 +161397,20 @@ static WORD_AUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["auctions"], &["auctions"], &["auctions"]], - range: 5..=7, + values: &[ + &["success"], + &["successive"], + &["auctions"], + &["auctions"], + &["auctions"], + ], + range: 4..=7, }; static WORD_AT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -84794,10 +161435,55 @@ static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_ATO_NODE), None, - 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("hentication")], + values: &[&["authentication"]], + range: 11..=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, @@ -84806,117 +161492,482 @@ static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, ]; -static WORD_ATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ATT_CHILDREN), +static WORD_ATTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ATTT_CHILDREN), value: None, }; -pub static WORD_ATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ATTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("achemnt"), - dictgen::InsensitiveStr::Ascii("achemnts"), - dictgen::InsensitiveStr::Ascii("achmet"), - dictgen::InsensitiveStr::Ascii("ackeras"), - dictgen::InsensitiveStr::Ascii("ackerasu"), - dictgen::InsensitiveStr::Ascii("ackerats"), - dictgen::InsensitiveStr::Ascii("ackes"), - dictgen::InsensitiveStr::Ascii("actment"), - dictgen::InsensitiveStr::Ascii("actments"), - dictgen::InsensitiveStr::Ascii("aindre"), - dictgen::InsensitiveStr::Ascii("emp"), - dictgen::InsensitiveStr::Ascii("emped"), - dictgen::InsensitiveStr::Ascii("emps"), - dictgen::InsensitiveStr::Ascii("emt"), - dictgen::InsensitiveStr::Ascii("emted"), - dictgen::InsensitiveStr::Ascii("emting"), - dictgen::InsensitiveStr::Ascii("emtped"), - dictgen::InsensitiveStr::Ascii("emtping"), - dictgen::InsensitiveStr::Ascii("emtps"), - dictgen::InsensitiveStr::Ascii("emts"), - dictgen::InsensitiveStr::Ascii("endence"), - dictgen::InsensitiveStr::Ascii("endent"), - dictgen::InsensitiveStr::Ascii("endents"), - dictgen::InsensitiveStr::Ascii("ened"), - dictgen::InsensitiveStr::Ascii("ension"), - dictgen::InsensitiveStr::Ascii("idute"), - dictgen::InsensitiveStr::Ascii("irbute"), - dictgen::InsensitiveStr::Ascii("irbutes"), - dictgen::InsensitiveStr::Ascii("irtion"), - dictgen::InsensitiveStr::Ascii("itide"), - dictgen::InsensitiveStr::Ascii("mepted"), - dictgen::InsensitiveStr::Ascii("mepting"), - dictgen::InsensitiveStr::Ascii("racs"), - dictgen::InsensitiveStr::Ascii("racters"), - dictgen::InsensitiveStr::Ascii("ractes"), - dictgen::InsensitiveStr::Ascii("ractice"), - dictgen::InsensitiveStr::Ascii("racties"), - dictgen::InsensitiveStr::Ascii("ractifs"), - dictgen::InsensitiveStr::Ascii("ractin"), - dictgen::InsensitiveStr::Ascii("raktion"), - dictgen::InsensitiveStr::Ascii("raktive"), - dictgen::InsensitiveStr::Ascii("ribue"), - dictgen::InsensitiveStr::Ascii("ribuito"), - dictgen::InsensitiveStr::Ascii("ributo"), - dictgen::InsensitiveStr::Ascii("ributred"), - dictgen::InsensitiveStr::Ascii("ributs"), - dictgen::InsensitiveStr::Ascii("ributted"), - dictgen::InsensitiveStr::Ascii("ritube"), - dictgen::InsensitiveStr::Ascii("ritubes"), - dictgen::InsensitiveStr::Ascii("rocities"), + 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: &[ - &["attachment"], - &["attachments"], - &["attachments"], - &["attackers"], - &["attackers"], - &["attackers"], - &["attackers"], - &["attachment"], - &["attachments"], - &["attainder"], - &["attempt"], - &["attempted"], - &["attempts"], - &["attempt"], - &["attempted"], - &["attempting"], - &["attempted"], - &["attempting"], - &["attempts"], - &["attempts"], - &["attendance"], - &["attendant"], - &["attendants"], - &["attended"], - &["attention"], - &["attitude"], &["attribute"], &["attributes"], - &["attrition"], - &["attitude"], - &["attempted"], - &["attempting"], - &["attracts"], - &["attracts"], - &["attracts"], - &["attractive"], - &["attracts"], - &["attracts"], - &["attraction"], - &["attraction"], - &["attractive"], &["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")], + values: &[&["attribute"]], + range: 5..=5, +}; + +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("btutes"), + dictgen::InsensitiveStr::Ascii("bude"), + dictgen::InsensitiveStr::Ascii("bue"), + dictgen::InsensitiveStr::Ascii("bues"), + 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("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("tube"), + dictgen::InsensitiveStr::Ascii("tubes"), + dictgen::InsensitiveStr::Ascii("ubtes"), + dictgen::InsensitiveStr::Ascii("ubute"), + ], + values: &[ + &["attribute"], + &["attribute"], + &["attributes"], + &["attribute"], + &["attributed"], + &["attributes", "attribute"], + &["attributing"], + &["attribute"], + &["attributes"], + &["attribute"], + &["attribute"], + &["attributes"], + &["attribute"], + &["attributes"], &["attribution"], &["attribution"], + &["attribute"], + &["attributed"], + &["attributes"], + &["attribute"], + &["attributed"], + &["attributes"], + &["attribution"], + &["attribute"], + &["attribute"], + &["attribute"], + &["attribution"], &["attributed"], &["attributes"], &["attribute"], &["attribute"], &["attributes"], - &["atrocities"], + &["attribute"], + &["attributes"], + &["attribute"], + &["attributed"], + &["attributes"], + &["attributing"], + &["attribute"], + &["attributes"], + &["attributes"], + &["attribute"], ], - range: 3..=8, + 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")], + values: &[&["attribute"]], + range: 4..=4, +}; + +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("sencond"), + dictgen::InsensitiveStr::Ascii("senconds"), + ], + values: &[&["attosecond"], &["attoseconds"]], + range: 7..=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"), + ], + values: &[&["attempt"], &["attempted"], &["attempting"], &["attempt"]], + 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("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("rtion"), + dictgen::InsensitiveStr::Ascii("tide"), + ], + values: &[ + &["attribute"], + &["attributed"], + &["attributes"], + &["attitude"], + &["attribute"], + &["attributes"], + &["attribute"], + &["attrition"], + &["attitude"], + ], + range: 4..=6, +}; + +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("mp"), + dictgen::InsensitiveStr::Ascii("mped"), + dictgen::InsensitiveStr::Ascii("mping"), + dictgen::InsensitiveStr::Ascii("mppt"), + dictgen::InsensitiveStr::Ascii("mps"), + 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("pmpt"), + dictgen::InsensitiveStr::Ascii("pt"), + dictgen::InsensitiveStr::Ascii("tntion"), + ], + values: &[ + &["attempt"], + &["attempted"], + &["attempting"], + &["attempt"], + &["attempts"], + &["attempting"], + &["attempt"], + &["attempted"], + &["attempting"], + &["attempt"], + &["attempted"], + &["attempting"], + &["attempts"], + &["attempted"], + &["attempts"], + &["attempts"], + &["attendance"], + &["attendant"], + &["attendants"], + &["attended"], + &["attenuation"], + &["attention"], + &["attended"], + &["attempt"], + &["attempt"], + &["attention"], + ], + range: 2..=8, +}; + +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 { @@ -84927,6 +161978,8 @@ static WORD_ATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -84938,9 +161991,15 @@ pub static WORD_ATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ocitites"), dictgen::InsensitiveStr::Ascii("ocoties"), 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"], @@ -84952,8 +162011,23 @@ pub static WORD_ATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["atrocities"], &["atrocities"], &["atrocities"], + &["attribute"], + &["attributes"], + &["attribute"], + &["attributes"], ], - range: 4..=8, + 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 { @@ -84963,18 +162037,28 @@ static WORD_ATO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("mzier"), + dictgen::InsensitiveStr::Ascii("recovery"), dictgen::InsensitiveStr::Ascii("rney"), ], values: &[ + &["automatically"], + &["atomic"], + &["atomically"], + &["atomicity"], &["atmosphere"], &["atmospheric"], &["atomizer"], + &["autorecovery"], &["attorney"], ], - range: 4..=8, + range: 4..=9, }; static WORD_ATM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -84984,6 +162068,8 @@ static WORD_ATM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -84994,6 +162080,8 @@ pub static WORD_ATM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("osphir"), ], values: &[ + &["atomic"], + &["atomically"], &["atomizer"], &["atmosphere"], &["atmospheric"], @@ -85003,7 +162091,7 @@ pub static WORD_ATM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["atmospheric"], &["atmospheric"], ], - range: 5..=9, + range: 3..=9, }; static WORD_ATL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85017,9 +162105,16 @@ pub static WORD_ATL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("antia"), dictgen::InsensitiveStr::Ascii("eats"), dictgen::InsensitiveStr::Ascii("esat"), + dictgen::InsensitiveStr::Ascii("l"), ], - values: &[&["atlantic"], &["atlanta"], &["atleast"], &["atleast"]], - range: 4..=5, + values: &[ + &["atlantic"], + &["atlanta"], + &["atleast"], + &["atleast"], + &["all"], + ], + range: 1..=5, }; static WORD_ATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85042,6 +162137,7 @@ pub static WORD_ATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -85049,6 +162145,7 @@ pub static WORD_ATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -85070,17 +162167,22 @@ pub static WORD_ATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("letisim"), dictgen::InsensitiveStr::Ascii("letisism"), dictgen::InsensitiveStr::Ascii("lets"), + 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"], @@ -85102,8 +162204,11 @@ pub static WORD_ATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["athleticism"], &["athleticism"], &["athletes"], + &["although"], + &["athlon"], + &["atheros"], ], - range: 4..=9, + range: 2..=9, }; static WORD_ATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85114,10 +162219,27 @@ static WORD_ATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), ], - values: &[&["atleast"], &["attempting"]], - range: 4..=6, + values: &[ + &["atleast"], + &["attempt"], + &["attempting"], + &["attempts"], + &["attendance"], + &["attended"], + &["attendee"], + &["attends"], + &["attention"], + ], + range: 3..=6, }; static WORD_ATC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85138,11 +162260,27 @@ static WORD_ATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("tchment"), dictgen::InsensitiveStr::Ascii("tchments"), ], - values: &[&["attain"], &["attachment"], &["attachments"]], + values: &[ + &["attach"], + &["attached"], + &["attaching"], + &["attachment"], + &["attachments"], + &["attack"], + &["attain"], + &["attachment"], + &["attachments"], + ], range: 2..=8, }; @@ -85187,11 +162325,76 @@ static WORD_ASY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("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("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: &[&["asynchronous"], &["asynchronous"]], - range: 8..=8, + values: &[ + &["asynchronize"], + &["asynchronized"], + &["asynchronous"], + &["asynchronously"], + &["async"], + &["asynchronous"], + &["asymmetric"], + &["asymmetric", "asymmetry"], + &["asymmetric"], + &["asymmetrical"], + &["asymmetrically"], + &["asymmetric"], + &["asymmetric", "asymmetry"], + &["asynchronous"], + &["asynchronous"], + &["asynchronously"], + &["asynchronous"], + &["asynchronous"], + &["asynchronous"], + &["asynchronously"], + &["asynchronous"], + &["asynchronous"], + &["asynchronously"], + &["asynchronous"], + &["asynchronous"], + &["asynchronous"], + &["asynchronous"], + &["asynchronous"], + &["asynchronously"], + &["asynchronous"], + &["asynchronously"], + &["async"], + &["asynchronous"], + ], + range: 2..=12, }; static WORD_ASU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85202,6 +162405,11 @@ static WORD_ASU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ASU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("me"), + dictgen::InsensitiveStr::Ascii("med"), + dictgen::InsensitiveStr::Ascii("mes"), + dictgen::InsensitiveStr::Ascii("ming"), + dictgen::InsensitiveStr::Ascii("mption"), + dictgen::InsensitiveStr::Ascii("re"), dictgen::InsensitiveStr::Ascii("terity"), dictgen::InsensitiveStr::Ascii("tralian"), dictgen::InsensitiveStr::Ascii("tria"), @@ -85209,6 +162417,11 @@ pub static WORD_ASU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["assume"], + &["assumed"], + &["assumes"], + &["assuming"], + &["assumption"], + &["assure"], &["austerity"], &["australian"], &["austria"], @@ -85226,6 +162439,7 @@ pub static WORD_AST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("eorid"), dictgen::InsensitiveStr::Ascii("eorids"), + dictgen::InsensitiveStr::Ascii("erices"), dictgen::InsensitiveStr::Ascii("ericks"), dictgen::InsensitiveStr::Ascii("erik"), dictgen::InsensitiveStr::Ascii("eriks"), @@ -85237,6 +162451,9 @@ pub static WORD_AST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -85264,9 +162481,10 @@ pub static WORD_AST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["asteroid"], &["asteroids"], + &["asterisks"], &["asterisk"], &["asterisk"], - &["asterisk"], + &["asterisk", "asterisks"], &["asteroid"], &["asteroids"], &["asteroids"], @@ -85275,6 +162493,9 @@ pub static WORD_AST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["aesthetic"], &["aesthetical"], &["aesthetically"], + &["aesthetics"], + &["estimate"], + &["estimation"], &["astonishing"], &["astonishing"], &["astonishing"], @@ -85310,11 +162531,11 @@ static WORD_ASS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: static WORD_ASS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ Some(&WORD_ASSA_NODE), None, - None, + Some(&WORD_ASSC_NODE), None, Some(&WORD_ASSE_NODE), None, - None, + Some(&WORD_ASSG_NODE), Some(&WORD_ASSH_NODE), Some(&WORD_ASSI_NODE), None, @@ -85345,9 +162566,24 @@ pub static WORD_ASSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"), ], - values: &[&["asymmetric"], &["asymmetrical"]], - range: 6..=8, + values: &[ + &["asymmetric"], + &["asymmetrical"], + &["asymmetries"], + &["asymmetry"], + &["asymmetric"], + &["asymmetrical"], + &["asymmetries"], + &["asymmetry"], + ], + range: 5..=9, }; static WORD_ASSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85360,19 +162596,109 @@ pub static WORD_ASSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("alt"), dictgen::InsensitiveStr::Ascii("alted"), dictgen::InsensitiveStr::Ascii("alts"), + dictgen::InsensitiveStr::Ascii("e"), + 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("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("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"], + &["assembly"], &["assaulted"], + &["assume"], + &["assume"], + &["assumed"], + &["assuming"], + &["assumes"], + &["assume"], + &["assumed"], + &["assumes"], + &["assuming"], + &["assumed"], + &["assuming"], + &["assume"], + &["assumed"], + &["assumes"], + &["assuming"], + &["assume"], + &["assumed"], + &["assumes"], + &["assuming"], + &["assuming"], + &["assumption"], &["assumptions"], + &["assumption"], &["assumptions"], + &["assumes"], + &["assumes"], + &["assumption"], + &["assumptions"], + &["assumption"], + &["assumptions"], + &["assume"], + &["assumed"], + &["assume"], + &["assumed"], + &["assumes"], + &["assuming"], + &["assuming"], + &["assumption"], + &["assumptions"], + &["assumes"], + &["assumption"], + &["assumptions"], + &["assumption"], + &["assumptions"], + &["assured"], ], - range: 3..=7, + range: 1..=8, }; static WORD_ASSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85385,10 +162711,31 @@ pub static WORD_ASSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("its"), + dictgen::InsensitiveStr::Ascii("ociated"), + dictgen::InsensitiveStr::Ascii("ume"), + dictgen::InsensitiveStr::Ascii("umes"), + dictgen::InsensitiveStr::Ascii("uming"), ], - values: &[&["assassin"], &["assassins"], &["assassins"], &["assists"]], - range: 3..=6, + values: &[ + &["assassin"], + &["assassins"], + &["assassins"], + &["assembler"], + &["assembly"], + &["assert"], + &["assertion"], + &["assists"], + &["associated"], + &["assume"], + &["assumes"], + &["assuming"], + ], + range: 3..=7, }; static WORD_ASSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85401,9 +162748,18 @@ pub static WORD_ASSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("caited"), dictgen::InsensitiveStr::Ascii("caites"), dictgen::InsensitiveStr::Ascii("caition"), + 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("cciative"), dictgen::InsensitiveStr::Ascii("ciaiton"), + dictgen::InsensitiveStr::Ascii("ciatated"), + dictgen::InsensitiveStr::Ascii("ciatd"), dictgen::InsensitiveStr::Ascii("ciatie"), + dictgen::InsensitiveStr::Ascii("ciatied"), dictgen::InsensitiveStr::Ascii("ciaties"), dictgen::InsensitiveStr::Ascii("ciatin"), dictgen::InsensitiveStr::Ascii("ciationg"), @@ -85411,18 +162767,39 @@ pub static WORD_ASSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("ciato"), dictgen::InsensitiveStr::Ascii("ciaton"), dictgen::InsensitiveStr::Ascii("ciatons"), + dictgen::InsensitiveStr::Ascii("cicate"), + dictgen::InsensitiveStr::Ascii("cicated"), + dictgen::InsensitiveStr::Ascii("cicates"), + dictgen::InsensitiveStr::Ascii("cicating"), + dictgen::InsensitiveStr::Ascii("cidated"), + dictgen::InsensitiveStr::Ascii("cieted"), dictgen::InsensitiveStr::Ascii("cisted"), + dictgen::InsensitiveStr::Ascii("cition"), + dictgen::InsensitiveStr::Ascii("ciuated"), + dictgen::InsensitiveStr::Ascii("ction"), + dictgen::InsensitiveStr::Ascii("iated"), dictgen::InsensitiveStr::Ascii("icate"), dictgen::InsensitiveStr::Ascii("icated"), dictgen::InsensitiveStr::Ascii("icates"), dictgen::InsensitiveStr::Ascii("ication"), dictgen::InsensitiveStr::Ascii("ications"), + dictgen::InsensitiveStr::Ascii("iciative"), + dictgen::InsensitiveStr::Ascii("mption"), + dictgen::InsensitiveStr::Ascii("sciate"), + dictgen::InsensitiveStr::Ascii("sciated"), + dictgen::InsensitiveStr::Ascii("sciates"), + dictgen::InsensitiveStr::Ascii("sciating"), + dictgen::InsensitiveStr::Ascii("siacition"), + dictgen::InsensitiveStr::Ascii("siacitions"), + dictgen::InsensitiveStr::Ascii("siacted"), + dictgen::InsensitiveStr::Ascii("siate"), dictgen::InsensitiveStr::Ascii("siated"), dictgen::InsensitiveStr::Ascii("siates"), dictgen::InsensitiveStr::Ascii("siating"), dictgen::InsensitiveStr::Ascii("siation"), dictgen::InsensitiveStr::Ascii("siations"), dictgen::InsensitiveStr::Ascii("sication"), + dictgen::InsensitiveStr::Ascii("tiated"), dictgen::InsensitiveStr::Ascii("tiations"), dictgen::InsensitiveStr::Ascii("ziation"), ], @@ -85430,8 +162807,17 @@ pub static WORD_ASSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["associated"], &["associates"], &["associations"], + &["associate"], + &["associated"], + &["associates"], + &["associating"], &["association"], &["associations"], + &["associative"], + &["associations"], + &["associated"], + &["associated"], + &["associated"], &["associated"], &["associates"], &["associations"], @@ -85440,22 +162826,43 @@ pub static WORD_ASSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["association"], &["association"], &["associations"], + &["associate"], + &["associated"], &["associates"], + &["associating"], + &["associated"], + &["associated"], + &["associates"], + &["association"], + &["associated"], + &["association"], + &["associated"], &["associate"], &["associated"], &["associates"], &["association"], &["associations"], + &["associative"], + &["assumption"], + &["associate"], + &["associated"], + &["associates"], + &["associating"], + &["association"], + &["associations"], + &["associated"], + &["associate"], &["associated"], &["associates"], &["associating"], &["association"], &["associations"], &["assassination"], + &["associated"], &["associations"], &["association"], ], - range: 5..=11, + range: 4..=11, }; static WORD_ASSN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85476,76 +162883,99 @@ static WORD_ASSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_ASSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("bler"), dictgen::InsensitiveStr::Ascii("eble"), dictgen::InsensitiveStr::Ascii("ebled"), dictgen::InsensitiveStr::Ascii("ebling"), dictgen::InsensitiveStr::Ascii("ebly"), + dictgen::InsensitiveStr::Ascii("elber"), + dictgen::InsensitiveStr::Ascii("ption"), + dictgen::InsensitiveStr::Ascii("ptions"), ], values: &[ + &["assembler"], &["assemble"], &["assembled"], &["assembling"], &["assembly"], + &["assembler"], + &["assumption"], + &["assumptions"], ], range: 4..=6, }; static WORD_ASSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ASSI_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ASSI_CHILDREN), value: None, }; -pub static WORD_ASSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_ASSI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + None, + None, + Some(&WORD_ASSID_NODE), + None, + None, + Some(&WORD_ASSIG_NODE), + None, + 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("de"), - dictgen::InsensitiveStr::Ascii("gnemnt"), - dictgen::InsensitiveStr::Ascii("gnemnts"), - dictgen::InsensitiveStr::Ascii("malate"), - dictgen::InsensitiveStr::Ascii("mialted"), - dictgen::InsensitiveStr::Ascii("milant"), - dictgen::InsensitiveStr::Ascii("milare"), - dictgen::InsensitiveStr::Ascii("milatie"), - dictgen::InsensitiveStr::Ascii("mile"), - dictgen::InsensitiveStr::Ascii("milerat"), - dictgen::InsensitiveStr::Ascii("miliate"), - dictgen::InsensitiveStr::Ascii("mliate"), - dictgen::InsensitiveStr::Ascii("mliated"), - dictgen::InsensitiveStr::Ascii("mulate"), - dictgen::InsensitiveStr::Ascii("ngment"), - dictgen::InsensitiveStr::Ascii("ngments"), - dictgen::InsensitiveStr::Ascii("snate"), - dictgen::InsensitiveStr::Ascii("ssinated"), - dictgen::InsensitiveStr::Ascii("sst"), - dictgen::InsensitiveStr::Ascii("stanat"), - dictgen::InsensitiveStr::Ascii("stans"), - dictgen::InsensitiveStr::Ascii("stanse"), - dictgen::InsensitiveStr::Ascii("stante"), - dictgen::InsensitiveStr::Ascii("stantes"), - dictgen::InsensitiveStr::Ascii("stat"), - dictgen::InsensitiveStr::Ascii("stence"), - dictgen::InsensitiveStr::Ascii("stendo"), - dictgen::InsensitiveStr::Ascii("stents"), - dictgen::InsensitiveStr::Ascii("stsnt"), - dictgen::InsensitiveStr::Ascii("t"), - dictgen::InsensitiveStr::Ascii("tant"), + 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("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: &[ - &["aside"], - &["assignment"], - &["assignments"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assimilate"], - &["assignment"], - &["assignments"], &["assassinate"], &["assassinated"], &["assists"], @@ -85557,12 +162987,182 @@ pub static WORD_ASSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["assistants"], &["assistance"], &["assisted"], - &["assistants"], - &["assistants"], - &["assist"], &["assistant"], + &["assistants"], + &["assistants"], ], - range: 1..=8, + 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("gs"), + dictgen::InsensitiveStr::Ascii("ment"), + ], + values: &[ + &["assigned"], + &["assign"], + &["assigned"], + &["assigning"], + &["assigned"], + &["assignment"], + &["assignments"], + &["assigned"], + &["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("ulate"), + ], + values: &[ + &["assimilate"], + &["assume"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + &["assimilate"], + ], + range: 1..=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("ing"), + dictgen::InsensitiveStr::Ascii("ment"), + dictgen::InsensitiveStr::Ascii("ments"), + dictgen::InsensitiveStr::Ascii("mnent"), + dictgen::InsensitiveStr::Ascii("nalble"), + 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("nenmet"), + dictgen::InsensitiveStr::Ascii("nes"), + dictgen::InsensitiveStr::Ascii("nmenet"), + dictgen::InsensitiveStr::Ascii("nmens"), + dictgen::InsensitiveStr::Ascii("nmet"), + dictgen::InsensitiveStr::Ascii("nmnet"), + dictgen::InsensitiveStr::Ascii("nt"), + dictgen::InsensitiveStr::Ascii("ntment"), + ], + values: &[ + &["assigned"], + &["assigned"], + &["assigning"], + &["assignment"], + &["assignments"], + &["assignment"], + &["assignable"], + &["assign", "assigned"], + &["assignment"], + &["assignments"], + &["assignment"], + &["assignments"], + &["assignment"], + &["assigned"], + &["assignment"], + &["assigns"], + &["assignment"], + &["assignments"], + &["assignment"], + &["assignment"], + &["assign"], + &["assignment"], + ], + range: 2..=7, +}; + +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_ASSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85579,6 +163179,31 @@ pub static WORD_ASSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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_ASSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ASSE_CHILDREN), value: None, @@ -85586,40 +163211,91 @@ static WORD_ASSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: pub static WORD_ASSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("bly"), + dictgen::InsensitiveStr::Ascii("bmly"), dictgen::InsensitiveStr::Ascii("mbe"), 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("mly"), + dictgen::InsensitiveStr::Ascii("mnly"), dictgen::InsensitiveStr::Ascii("mple"), dictgen::InsensitiveStr::Ascii("mpling"), + dictgen::InsensitiveStr::Ascii("nding"), + dictgen::InsensitiveStr::Ascii("r"), + dictgen::InsensitiveStr::Ascii("rsion"), dictgen::InsensitiveStr::Ascii("rsions"), dictgen::InsensitiveStr::Ascii("rtation"), dictgen::InsensitiveStr::Ascii("rtin"), + dictgen::InsensitiveStr::Ascii("rtio"), + dictgen::InsensitiveStr::Ascii("rtting"), dictgen::InsensitiveStr::Ascii("sement"), + dictgen::InsensitiveStr::Ascii("smenet"), + dictgen::InsensitiveStr::Ascii("sment"), + dictgen::InsensitiveStr::Ascii("ssmant"), dictgen::InsensitiveStr::Ascii("stment"), ], values: &[ + &["assembly"], + &["assembly"], &["assemble"], &["assembled"], + &["assembler"], &["assemble"], &["assembling"], &["assembly"], &["assemble"], &["assembling"], + &["assemblies"], + &["assembly"], + &["assembly"], &["assembly"], &["assemble"], &["assembling"], + &["ascending"], + &["assert"], + &["assertion"], &["assertions"], &["assertion"], &["assertions"], + &["assertion"], + &["asserting"], + &["assessment"], + &["assessment"], + &["assessment"], &["assessment"], &["assessment"], ], - range: 3..=7, + range: 1..=7, +}; + +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 { @@ -85693,6 +163369,7 @@ static WORD_ASP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -85704,6 +163381,7 @@ pub static WORD_ASP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["asphalt"], + &["expected"], &["aspects"], &["aspergers"], &["aspergers"], @@ -85724,9 +163402,10 @@ static WORD_ASO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["absorbed"]], + values: &[&["associated"], &["absolute"], &["absorbed"]], range: 4..=6, }; @@ -85737,12 +163416,26 @@ static WORD_ASN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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: &[&["answered"], &["answering"], &["answers"]], - range: 4..=6, + values: &[ + &["answer"], + &["answered"], + &["answerer"], + &["answerers"], + &["answering"], + &["answers"], + &["any"], + &["asynchronous"], + ], + range: 1..=9, }; static WORD_ASL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85762,9 +163455,13 @@ static WORD_ASK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ASK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("reddt")], - values: &[&["askreddit"]], - range: 5..=5, + 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 { @@ -85775,19 +163472,39 @@ static WORD_ASI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], + &["assignor"], + &["assigns"], + &["ascii"], &["aspirin"], + &["assistant"], &["assistants"], &["assisted"], &["assists"], + &["assistance"], ], - range: 2..=7, + range: 1..=7, }; static WORD_ASH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85808,6 +163525,19 @@ static WORD_ASE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ASE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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("thetic"), dictgen::InsensitiveStr::Ascii("thetically"), dictgen::InsensitiveStr::Ascii("thetics"), @@ -85816,6 +163546,19 @@ pub static WORD_ASE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("xaul"), ], values: &[ + &["ascend"], + &["ascendance"], + &["ascendancy"], + &["ascendancy"], + &["ascended"], + &["ascendence"], + &["ascendency"], + &["ascendency"], + &["ascender"], + &["ascending"], + &["ascent"], + &["asserted"], + &["assertion"], &["aesthetic"], &["aesthetically"], &["aesthetics"], @@ -85823,7 +163566,7 @@ pub static WORD_ASE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["asexual"], &["asexual"], ], - range: 3..=10, + range: 2..=10, }; static WORD_ASC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85833,12 +163576,19 @@ static WORD_ASC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ASC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("eding"), dictgen::InsensitiveStr::Ascii("endend"), dictgen::InsensitiveStr::Ascii("neded"), dictgen::InsensitiveStr::Ascii("neding"), dictgen::InsensitiveStr::Ascii("nesion"), ], - values: &[&["ascended"], &["ascended"], &["ascending"], &["ascension"]], + values: &[ + &["ascending"], + &["ascended"], + &["ascended"], + &["ascending"], + &["ascension"], + ], range: 5..=6, }; @@ -85851,20 +163601,46 @@ pub static WORD_ASB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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..=7, + range: 5..=9, }; static WORD_ASA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -85873,9 +163649,13 @@ static WORD_ASA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ASA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("pragus")], - values: &[&["asparagus"]], - range: 6..=6, + 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 { @@ -85887,7 +163667,7 @@ static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_ARA_NODE), Some(&WORD_ARB_NODE), Some(&WORD_ARC_NODE), - None, + Some(&WORD_ARD_NODE), Some(&WORD_ARE_NODE), None, Some(&WORD_ARG_NODE), @@ -85900,7 +163680,7 @@ static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_ARO_NODE), Some(&WORD_ARP_NODE), - None, + Some(&WORD_ARQ_NODE), Some(&WORD_ARR_NODE), Some(&WORD_ARS_NODE), Some(&WORD_ART_NODE), @@ -85926,6 +163706,7 @@ pub static WORD_ARU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("gment"), dictgen::InsensitiveStr::Ascii("gmentative"), dictgen::InsensitiveStr::Ascii("gments"), + dictgen::InsensitiveStr::Ascii("ments"), dictgen::InsensitiveStr::Ascii("nd"), ], values: &[ @@ -85936,6 +163717,7 @@ pub static WORD_ARU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["argument"], &["argumentative"], &["arguments"], + &["arguments"], &["around"], ], range: 2..=10, @@ -85954,7 +163736,12 @@ pub static WORD_ART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("himetic"), dictgen::InsensitiveStr::Ascii("hirtis"), dictgen::InsensitiveStr::Ascii("hrits"), + 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("icifial"), @@ -85986,6 +163773,7 @@ pub static WORD_ART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("istc"), dictgen::InsensitiveStr::Ascii("meis"), dictgen::InsensitiveStr::Ascii("sits"), + dictgen::InsensitiveStr::Ascii("uments"), ], values: &[ &["article"], @@ -85994,7 +163782,12 @@ pub static WORD_ART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["arithmetic"], &["arthritis"], &["arthritis"], + &["artifact"], + &["artifacts"], &["article"], + &["articles"], + &["artifact"], + &["artifacts"], &["article"], &["article"], &["artificial"], @@ -86026,6 +163819,7 @@ pub static WORD_ART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["artistic"], &["artemis"], &["artists"], + &["arguments"], ], range: 3..=9, }; @@ -86045,38 +163839,249 @@ pub static WORD_ARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_ARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ARR_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ARR_CHILDREN), value: None, }; -pub static WORD_ARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("s")], + values: &[&["arrays"]], + range: 1..=1, +}; + +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("agned"), - dictgen::InsensitiveStr::Ascii("angerad"), - dictgen::InsensitiveStr::Ascii("angment"), - dictgen::InsensitiveStr::Ascii("angments"), - dictgen::InsensitiveStr::Ascii("ary"), - dictgen::InsensitiveStr::Ascii("engement"), - dictgen::InsensitiveStr::Ascii("engements"), - dictgen::InsensitiveStr::Ascii("esst"), - dictgen::InsensitiveStr::Ascii("estes"), - dictgen::InsensitiveStr::Ascii("estos"), - dictgen::InsensitiveStr::Ascii("ound"), + dictgen::InsensitiveStr::Ascii("ay"), + dictgen::InsensitiveStr::Ascii("ays"), + dictgen::InsensitiveStr::Ascii("ives"), + ], + values: &[&["array"], &["arrays"], &["arrives"]], + range: 2..=4, +}; + +static WORD_ARRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ARRO_CHILDREN), + value: None, +}; + +pub static WORD_ARRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("und")], + values: &[&["around"]], + range: 3..=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("veis"), + dictgen::InsensitiveStr::Ascii("vial"), + ], + values: &[&["arrives"], &["arrival"]], + range: 4..=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: &[ - &["arranged"], - &["arranged"], - &["arrangement"], - &["arrangements"], &["array"], &["arrangement"], &["arrangements"], &["arrests"], &["arrests"], &["arrests"], - &["around"], ], - range: 3..=9, + 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("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("ows"), + dictgen::InsensitiveStr::Ascii("ry"), + dictgen::InsensitiveStr::Ascii("yes"), + ], + values: &[ + &["array"], + &["arrangement"], + &["arranged"], + &["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"], + &["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 { @@ -86103,9 +164108,19 @@ pub static WORD_ARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("gant"), dictgen::InsensitiveStr::Ascii("gent"), + dictgen::InsensitiveStr::Ascii("nud"), dictgen::InsensitiveStr::Ascii("ud"), + dictgen::InsensitiveStr::Ascii("ung"), + dictgen::InsensitiveStr::Ascii("unt"), + ], + values: &[ + &["arrogant"], + &["arrogant"], + &["around"], + &["around"], + &["around"], + &["around"], ], - values: &[&["arrogant"], &["arrogant"], &["around"]], range: 2..=4, }; @@ -86132,6 +164147,7 @@ pub static WORD_ARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("enain"), dictgen::InsensitiveStr::Ascii("enina"), dictgen::InsensitiveStr::Ascii("istace"), + dictgen::InsensitiveStr::Ascii("onic"), dictgen::InsensitiveStr::Ascii("pitts"), dictgen::InsensitiveStr::Ascii("storng"), dictgen::InsensitiveStr::Ascii("strog"), @@ -86153,6 +164169,7 @@ pub static WORD_ARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["armenian"], &["armenian"], &["armistice"], + &["harmonic"], &["armpits"], &["armstrong"], &["armstrong"], @@ -86170,8 +164187,9 @@ pub static WORD_ARL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ighty"), dictgen::InsensitiveStr::Ascii("ignton"), dictgen::InsensitiveStr::Ascii("ingotn"), + dictgen::InsensitiveStr::Ascii("ready"), ], - values: &[&["alrighty"], &["arlington"], &["arlington"]], + values: &[&["alrighty"], &["arlington"], &["arlington"], &["already"]], range: 5..=6, }; @@ -86193,6 +164211,8 @@ static WORD_ARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("bter"), dictgen::InsensitiveStr::Ascii("btrarily"), @@ -86211,18 +164231,27 @@ pub static WORD_ARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], &["arbiter"], &["arbitrarily"], @@ -86248,11 +164277,18 @@ pub static WORD_ARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["arithmetic"], &["arithmetic"], &["arithmetic"], + &["arithmetic"], + &["arithmetic"], + &["arithmetic"], + &["arithmetic"], + &["arbitrary"], + &["artist"], &["artists"], &["arrival"], + &["arrive"], &["arizona"], ], - range: 3..=9, + range: 2..=9, }; static WORD_ARH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -86261,9 +164297,13 @@ static WORD_ARH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ARH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("tritis")], - values: &[&["arthritis"]], - range: 6..=6, + 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 { @@ -86273,12 +164313,18 @@ static WORD_ARG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("uabley"), dictgen::InsensitiveStr::Ascii("uablly"), dictgen::InsensitiveStr::Ascii("ubaly"), @@ -86286,22 +164332,47 @@ pub static WORD_ARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("umant"), + dictgen::InsensitiveStr::Ascii("umants"), dictgen::InsensitiveStr::Ascii("umeent"), + 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("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("umet"), + dictgen::InsensitiveStr::Ascii("umetn"), + dictgen::InsensitiveStr::Ascii("umetns"), + dictgen::InsensitiveStr::Ascii("umets"), + dictgen::InsensitiveStr::Ascii("umnet"), + dictgen::InsensitiveStr::Ascii("umnets"), ], values: &[ + &["argument"], + &["arguments"], + &["argument"], + &["arguments"], &["argentina"], &["argentina"], &["aggressive"], &["argument"], &["agricultural"], &["agriculture"], + &["argument"], + &["arguments"], &["arguably"], &["arguably"], &["arguably"], @@ -86309,14 +164380,33 @@ pub static WORD_ARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["arguments"], &["arguement"], &["argument"], - &["arguments"], - &["arguement"], &["argument"], &["arguments"], + &["arguement", "argument"], + &["arguments"], + &["argument"], + &["arguments"], + &["argument"], + &["argument"], + &["arguments"], + &["argument"], + &["arguments"], + &["argument"], + &["arguments"], + &["arguments"], + &["arguments"], &["argumentative"], &["argumentative"], + &["arguments"], &["argumentative"], &["arguments"], + &["argument"], + &["argument"], + &["argument"], + &["arguments"], + &["arguments"], + &["argument"], + &["arguments"], ], range: 4..=10, }; @@ -86329,6 +164419,7 @@ static WORD_ARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -86338,6 +164429,7 @@ pub static WORD_ARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["already"], + &["area"], &["argument"], &["armenian"], &["aerodynamics"], @@ -86345,106 +164437,267 @@ pub static WORD_ARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["arsenal"], &["artemis"], ], - range: 3..=9, + range: 2..=9, }; -static WORD_ARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ARC_CHILDREN), +static WORD_ARD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ARD_CHILDREN), value: None, }; -pub static WORD_ARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ARD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[dictgen::InsensitiveStr::Ascii("iuno")], + values: &[&["arduino"]], + range: 4..=4, +}; + +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("aheology"), - dictgen::InsensitiveStr::Ascii("ahic"), - dictgen::InsensitiveStr::Ascii("ehtype"), - dictgen::InsensitiveStr::Ascii("ehtypes"), - dictgen::InsensitiveStr::Ascii("haelogical"), - dictgen::InsensitiveStr::Ascii("haelogists"), - dictgen::InsensitiveStr::Ascii("haelogy"), - dictgen::InsensitiveStr::Ascii("haeolgy"), - dictgen::InsensitiveStr::Ascii("haoelogy"), - dictgen::InsensitiveStr::Ascii("haology"), - dictgen::InsensitiveStr::Ascii("hatypes"), - dictgen::InsensitiveStr::Ascii("heaologist"), - dictgen::InsensitiveStr::Ascii("heaologists"), - dictgen::InsensitiveStr::Ascii("heaology"), - dictgen::InsensitiveStr::Ascii("hetect"), - dictgen::InsensitiveStr::Ascii("hetects"), - dictgen::InsensitiveStr::Ascii("hetectural"), - dictgen::InsensitiveStr::Ascii("hetecturally"), - dictgen::InsensitiveStr::Ascii("hetecture"), - dictgen::InsensitiveStr::Ascii("hetipes"), - dictgen::InsensitiveStr::Ascii("hetpye"), - dictgen::InsensitiveStr::Ascii("hetpyes"), - dictgen::InsensitiveStr::Ascii("hetyps"), - dictgen::InsensitiveStr::Ascii("hetypus"), - dictgen::InsensitiveStr::Ascii("heytpes"), - dictgen::InsensitiveStr::Ascii("hiac"), - dictgen::InsensitiveStr::Ascii("hictect"), - dictgen::InsensitiveStr::Ascii("himedian"), - dictgen::InsensitiveStr::Ascii("hitechs"), - dictgen::InsensitiveStr::Ascii("hitecht"), - dictgen::InsensitiveStr::Ascii("hitechts"), - dictgen::InsensitiveStr::Ascii("hitechturally"), - dictgen::InsensitiveStr::Ascii("hitechture"), - dictgen::InsensitiveStr::Ascii("hitechtures"), - dictgen::InsensitiveStr::Ascii("hitechural"), - dictgen::InsensitiveStr::Ascii("hitechure"), - dictgen::InsensitiveStr::Ascii("hitecs"), - dictgen::InsensitiveStr::Ascii("hitecte"), - dictgen::InsensitiveStr::Ascii("hitectes"), - dictgen::InsensitiveStr::Ascii("hitectrual"), - dictgen::InsensitiveStr::Ascii("hitectual"), - dictgen::InsensitiveStr::Ascii("hitectureal"), - dictgen::InsensitiveStr::Ascii("hitecturial"), - dictgen::InsensitiveStr::Ascii("hitectuur"), - dictgen::InsensitiveStr::Ascii("hitecure"), - dictgen::InsensitiveStr::Ascii("hitecutral"), - dictgen::InsensitiveStr::Ascii("hitecutre"), - dictgen::InsensitiveStr::Ascii("hitet"), - dictgen::InsensitiveStr::Ascii("hitexts"), - dictgen::InsensitiveStr::Ascii("hitexture"), - dictgen::InsensitiveStr::Ascii("hitypes"), - dictgen::InsensitiveStr::Ascii("htiects"), - dictgen::InsensitiveStr::Ascii("htype"), - dictgen::InsensitiveStr::Ascii("htypes"), - dictgen::InsensitiveStr::Ascii("hytypes"), - dictgen::InsensitiveStr::Ascii("itechture"), - dictgen::InsensitiveStr::Ascii("ylic"), + dictgen::InsensitiveStr::Ascii("techture"), + dictgen::InsensitiveStr::Ascii("tecture"), + dictgen::InsensitiveStr::Ascii("tectures"), + ], + values: &[&["architecture"], &["architecture"], &["architectures"]], + range: 7..=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: &[ - &["archeology"], - &["archaic"], - &["archetype"], - &["archetypes"], - &["archaeological"], - &["archaeologists"], - &["archaeology"], - &["archaeology"], - &["archaeology"], - &["archeology"], - &["archetypes"], - &["archeologist"], - &["archeologists"], - &["archeology"], - &["architect"], - &["architects"], - &["architectural"], - &["architecturally"], &["architecture"], - &["archetypes"], + &["architectures"], + &["architects"], + &["architecture"], + &["architectures"], + &["architecture"], + &["architectures"], &["archetype"], &["archetypes"], - &["archetypes"], - &["archetypes"], - &["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("median"), + 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"], &["archimedean"], + &["architect"], + &["architects"], + &["architecture"], + &["architectures"], &["architects"], &["architect"], - &["architect"], + &["architect", "architects"], &["architecturally"], &["architecture"], &["architectures"], @@ -86455,79 +164708,484 @@ pub static WORD_ARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["architects"], &["architectural"], &["architectural"], - &["architectural"], - &["architectural"], - &["architecture"], &["architecture"], &["architectural"], + &["architectural"], + &["architectures"], + &["architectures"], &["architecture"], + &["architecture"], + &["architectures"], + &["architectural"], + &["architecture"], + &["architectures"], + &["architecture"], + &["architectures"], &["architect"], + &["architecture"], + &["architectures"], + &["architecture"], + &["architectures"], &["architects"], &["architecture"], - &["archetypes"], - &["architects"], - &["archetype"], - &["archetypes"], - &["archetypes"], &["architecture"], - &["acrylic"], + &["architectures"], + &["archetypes"], + &["archive"], + &["archival"], ], - range: 4..=13, + range: 1..=11, }; -static WORD_ARB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ARB_CHILDREN), +static WORD_ARCHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ARCHE_CHILDREN), value: None, }; -pub static WORD_ARB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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", "archeologist"], + &["archeologists", "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] = [ + None, + 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("irtary"), dictgen::InsensitiveStr::Ascii("itarily"), dictgen::InsensitiveStr::Ascii("itary"), - dictgen::InsensitiveStr::Ascii("itraily"), - dictgen::InsensitiveStr::Ascii("itraion"), - dictgen::InsensitiveStr::Ascii("itrairly"), - dictgen::InsensitiveStr::Ascii("itrairy"), - dictgen::InsensitiveStr::Ascii("itralily"), - dictgen::InsensitiveStr::Ascii("itrarely"), - dictgen::InsensitiveStr::Ascii("itrariliy"), - dictgen::InsensitiveStr::Ascii("itrarilly"), - dictgen::InsensitiveStr::Ascii("itrarion"), - dictgen::InsensitiveStr::Ascii("itrarly"), - dictgen::InsensitiveStr::Ascii("itratily"), - dictgen::InsensitiveStr::Ascii("itraton"), - dictgen::InsensitiveStr::Ascii("itray"), - dictgen::InsensitiveStr::Ascii("itre"), - dictgen::InsensitiveStr::Ascii("iture"), - dictgen::InsensitiveStr::Ascii("ritarily"), - dictgen::InsensitiveStr::Ascii("ritary"), - dictgen::InsensitiveStr::Ascii("ritation"), + 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("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", "arbitrary"], + &["arbitrary", "arbitrarily"], + &["arbitrarily"], &["arbitrary"], &["arbitrarily"], &["arbitration"], + &["arbitration"], + &["arbitrarily"], + &["arbitration"], + &["arbitrary"], + &["arbitrary"], &["arbitrary"], &["arbiter"], - &["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: 4..=9, + 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_ARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -86537,12 +165195,26 @@ static WORD_ARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + 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: &[&["armageddon"], &["arranged"], &["arrangement"]], - range: 4..=7, + values: &[ + &["parameters"], + &["armageddon"], + &["arranged"], + &["arrangement"], + &["around"], + &["arabic"], + &["array"], + &["arrays"], + ], + range: 1..=7, }; static WORD_AQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -86552,52 +165224,70 @@ static WORD_AQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("uiantance"), dictgen::InsensitiveStr::Ascii("uire"), dictgen::InsensitiveStr::Ascii("uired"), + dictgen::InsensitiveStr::Ascii("uires"), dictgen::InsensitiveStr::Ascii("uiring"), dictgen::InsensitiveStr::Ascii("uisition"), + 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"], &["acquaintance"], &["acquire"], &["acquired"], + &["acquires"], &["acquiring"], &["acquisition"], + &["acquit"], &["acquitted"], + &["acquires", "equerries"], ], - range: 4..=11, + range: 3..=11, }; static WORD_AP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -86609,12 +165299,12 @@ static WORD_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_APA_NODE), None, None, - None, + Some(&WORD_APD_NODE), Some(&WORD_APE_NODE), None, None, None, - None, + Some(&WORD_API_NODE), None, None, Some(&WORD_APL_NODE), @@ -86682,23 +165372,87 @@ static WORD_APR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("eteate"), + dictgen::InsensitiveStr::Ascii("eteated"), + dictgen::InsensitiveStr::Ascii("eteating"), 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("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"], + &["appreciate"], + &["appreciated"], + &["appreciating"], &["aperture"], + &["approach"], + &["approached"], + &["approaches"], + &["approaching"], + &["approach"], + &["approached"], + &["approaches"], + &["approaching"], + &["approve"], + &["approved"], &["appropriate"], + &["appropriately"], + &["appropriate"], + &["appropriately"], &["approval"], &["approximate"], &["approximately"], + &["approximates"], + &["approximation"], + &["approximations"], + &["approval"], + &["approximate"], + &["approximately"], + &["approximates"], + &["approximation"], + &["approximations"], + &["apartment"], ], - range: 4..=9, + range: 3..=11, }; static WORD_APP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -86720,9 +165474,9 @@ static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] None, Some(&WORD_APPL_NODE), None, - None, + Some(&WORD_APPN_NODE), Some(&WORD_APPO_NODE), - None, + Some(&WORD_APPP_NODE), None, Some(&WORD_APPR_NODE), None, @@ -86731,10 +165485,21 @@ static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] 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, @@ -86756,7 +165521,7 @@ static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, None, Some(&WORD_APPRO_NODE), - None, + Some(&WORD_APPRP_NODE), None, None, None, @@ -86769,81 +165534,370 @@ static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str None, ]; -static WORD_APPRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_APPRO_CHILDREN), +static WORD_APPRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_APPRP_CHILDREN), value: None, }; -pub static WORD_APPRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_APPRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("achs"), - dictgen::InsensitiveStr::Ascii("acing"), - dictgen::InsensitiveStr::Ascii("piate"), - dictgen::InsensitiveStr::Ascii("pirate"), - dictgen::InsensitiveStr::Ascii("pirately"), - dictgen::InsensitiveStr::Ascii("piration"), - dictgen::InsensitiveStr::Ascii("praite"), - dictgen::InsensitiveStr::Ascii("praitely"), - dictgen::InsensitiveStr::Ascii("prate"), - dictgen::InsensitiveStr::Ascii("preation"), - dictgen::InsensitiveStr::Ascii("priatin"), - dictgen::InsensitiveStr::Ascii("priatley"), - dictgen::InsensitiveStr::Ascii("priatly"), - dictgen::InsensitiveStr::Ascii("priato"), - dictgen::InsensitiveStr::Ascii("priaton"), - dictgen::InsensitiveStr::Ascii("prietly"), - dictgen::InsensitiveStr::Ascii("propiate"), - dictgen::InsensitiveStr::Ascii("proximate"), - dictgen::InsensitiveStr::Ascii("rpiation"), - dictgen::InsensitiveStr::Ascii("straphe"), - dictgen::InsensitiveStr::Ascii("xamate"), - dictgen::InsensitiveStr::Ascii("xamately"), - dictgen::InsensitiveStr::Ascii("xiamte"), - dictgen::InsensitiveStr::Ascii("xiamtely"), - dictgen::InsensitiveStr::Ascii("xiately"), - dictgen::InsensitiveStr::Ascii("ximatelly"), - dictgen::InsensitiveStr::Ascii("ximatley"), - dictgen::InsensitiveStr::Ascii("ximatly"), - dictgen::InsensitiveStr::Ascii("ximetly"), - dictgen::InsensitiveStr::Ascii("ximitely"), - dictgen::InsensitiveStr::Ascii("xmiate"), + 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: &[ - &["approaches"], - &["approaching"], - &["appropriate"], - &["appropriate"], - &["appropriately"], - &["appropriation"], - &["appropriate"], - &["appropriately"], - &["appropriate"], - &["appropriation"], - &["appropriation"], - &["appropriately"], - &["appropriately"], - &["appropriation"], - &["appropriation"], - &["appropriately"], - &["appropriate"], - &["approximate"], - &["appropriation"], - &["apostrophe"], &["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("riatin"), + dictgen::InsensitiveStr::Ascii("riatley"), + dictgen::InsensitiveStr::Ascii("riatly"), + dictgen::InsensitiveStr::Ascii("riatness"), + dictgen::InsensitiveStr::Ascii("riato"), + dictgen::InsensitiveStr::Ascii("riaton"), + dictgen::InsensitiveStr::Ascii("rietly"), + dictgen::InsensitiveStr::Ascii("ritae"), + 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"], + &["appropriation"], + &["appropriately"], + &["appropriately"], + &["appropriateness"], + &["appropriation"], + &["appropriation"], + &["appropriately"], + &["appropriate"], + &["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")], + values: &[&["appropriate"]], + range: 3..=3, +}; + +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, @@ -86857,6 +165911,22 @@ pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di dictgen::InsensitiveStr::Ascii("ciates"), dictgen::InsensitiveStr::Ascii("ecate"), dictgen::InsensitiveStr::Ascii("eciate"), + dictgen::InsensitiveStr::Ascii("opriate"), + dictgen::InsensitiveStr::Ascii("priate"), + 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"], @@ -86865,8 +165935,24 @@ pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["appreciates"], &["appreciates"], &["appreciate"], + &["appropriate"], + &["appropriate"], + &["approximate"], + &["approximated"], + &["approximately"], + &["approximates"], + &["approximating"], + &["approximation"], + &["approximations"], + &["approximate"], + &["approximated"], + &["approximately"], + &["approximates"], + &["approximating"], + &["approximation"], + &["approximations"], ], - range: 5..=6, + range: 5..=9, }; static WORD_APPRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -86902,11 +165988,15 @@ pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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("tiation"), dictgen::InsensitiveStr::Ascii("tince"), @@ -86938,11 +166028,15 @@ pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di &["appreciates"], &["appreciating"], &["appreciation"], + &["appended", "apprehended"], &["apprentice"], &["apprentice"], &["apprentice"], &["apprentice"], &["apprentice"], + &["apparently"], + &["appreciate"], + &["appreciated"], &["appreciate"], &["appreciation"], &["apprentice"], @@ -86973,6 +166067,41 @@ pub static WORD_APPRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = di 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, @@ -86985,16 +166114,29 @@ pub static WORD_APPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("rpriately"), dictgen::InsensitiveStr::Ascii("rpriation"), dictgen::InsensitiveStr::Ascii("rximate"), dictgen::InsensitiveStr::Ascii("rximately"), + dictgen::InsensitiveStr::Ascii("ve"), + dictgen::InsensitiveStr::Ascii("ved"), + dictgen::InsensitiveStr::Ascii("ximate"), + dictgen::InsensitiveStr::Ascii("ximately"), + dictgen::InsensitiveStr::Ascii("ximates"), + dictgen::InsensitiveStr::Ascii("ximation"), + dictgen::InsensitiveStr::Ascii("ximations"), ], values: &[ &["appointments"], @@ -87002,18 +166144,42 @@ pub static WORD_APPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["appointments"], &["apologies"], &["apology"], + &["upon"], + &["appropriate"], &["approach"], &["approachable"], &["approached"], &["approaches"], &["approaching"], &["appropriate"], + &["approximate"], + &["approximated"], + &["appropriate"], + &["appropriate"], &["appropriately"], &["appropriation"], &["approximate"], &["approximately"], + &["approve"], + &["approved"], + &["approximate"], + &["approximately"], + &["approximates"], + &["approximation"], + &["approximations"], ], - range: 4..=9, + range: 1..=9, +}; + +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 { @@ -87026,39 +166192,89 @@ pub static WORD_APPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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("iable"), + dictgen::InsensitiveStr::Ascii("icabel"), dictgen::InsensitiveStr::Ascii("icabile"), + dictgen::InsensitiveStr::Ascii("icaion"), dictgen::InsensitiveStr::Ascii("icaiton"), dictgen::InsensitiveStr::Ascii("icaitons"), + dictgen::InsensitiveStr::Ascii("icance"), dictgen::InsensitiveStr::Ascii("icaple"), + dictgen::InsensitiveStr::Ascii("icatable"), + dictgen::InsensitiveStr::Ascii("icaten"), dictgen::InsensitiveStr::Ascii("icates"), + dictgen::InsensitiveStr::Ascii("icatin"), 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("iences"), + dictgen::InsensitiveStr::Ascii("ikation"), + dictgen::InsensitiveStr::Ascii("ing"), 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("ys"), + dictgen::InsensitiveStr::Ascii("yting"), ], values: &[ &["appliances"], &["applause"], &["applaud"], - &["applicable"], + &["apply"], &["application"], &["applications"], &["applicable"], + &["applicable"], + &["applicable"], + &["application"], + &["application"], + &["applications"], + &["appliance"], + &["applicable"], + &["applicable"], + &["application"], &["applicants"], + &["application"], &["applicants"], &["application"], &["application"], &["applications"], + &["applications"], + &["application"], + &["application"], + &["applications"], &["applicable"], + &["application"], + &["applications"], &["appliances"], + &["application"], + &["applying", "appalling"], &["applaud"], &["applause"], + &["applicable"], + &["applicable"], + &["applied"], + &["applies"], + &["applied"], + &["applies"], + &["applying"], ], - range: 3..=8, + range: 2..=8, }; static WORD_APPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87067,9 +166283,29 @@ static WORD_APPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_APPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("cation")], - values: &[&["application"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("cability"), + dictgen::InsensitiveStr::Ascii("cable"), + dictgen::InsensitiveStr::Ascii("caliton"), + 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"], + &["applicant"], + &["application"], + &["applications"], + &["applicative"], + &["applied"], + &["applies"], + ], + range: 2..=8, }; static WORD_APPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87081,14 +166317,30 @@ pub static WORD_APPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic keys: &[ dictgen::InsensitiveStr::Ascii("alling"), 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("ciate"), + dictgen::InsensitiveStr::Ascii("ded"), + dictgen::InsensitiveStr::Ascii("dn"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("ndend"), + dictgen::InsensitiveStr::Ascii("ndent"), + dictgen::InsensitiveStr::Ascii("ndign"), + dictgen::InsensitiveStr::Ascii("ned"), + dictgen::InsensitiveStr::Ascii("neded"), 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("rciate"), dictgen::InsensitiveStr::Ascii("rciated"), @@ -87097,21 +166349,42 @@ pub static WORD_APPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"], + &["appealing", "appalling"], &["appearances"], + &["apparently"], &["appeared"], &["appearance"], &["appearance"], &["appearances"], + &["apparently"], + &["appears"], &["appearances"], + &["appearing"], + &["appreciate"], + &["appended"], + &["append"], + &["append"], + &["appended"], + &["appended"], + &["appending"], + &["append", "appended", "happened"], + &["appended"], &["apennines"], + &["appends"], + &["append"], &["appearance"], &["appearances"], + &["apparent", "aberrant"], &["apparently"], &["appreciate"], &["appreciated"], @@ -87120,11 +166393,16 @@ pub static WORD_APPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["appeared"], &["appearance"], &["appearances"], + &["appeared"], + &["apparent"], + &["apparently"], + &["appears"], + &["aperture"], &["appetite"], &["appetite"], &["appetite"], ], - range: 3..=8, + range: 1..=8, }; static WORD_APPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87142,9 +166420,12 @@ pub static WORD_APPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("reance"), dictgen::InsensitiveStr::Ascii("reances"), 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("roches"), dictgen::InsensitiveStr::Ascii("rt"), dictgen::InsensitiveStr::Ascii("rtment"), dictgen::InsensitiveStr::Ascii("rtments"), @@ -87158,9 +166439,12 @@ pub static WORD_APPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["appearance"], &["appearances"], &["apparel"], + &["appearance"], &["apparently"], &["apparently"], &["apparently"], + &["apparently"], + &["approaches"], &["apart"], &["apartment"], &["apartments"], @@ -87188,6 +166472,10 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("calytpic"), dictgen::InsensitiveStr::Ascii("caplyse"), dictgen::InsensitiveStr::Ascii("colapse"), + 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"), @@ -87205,6 +166493,7 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("straphe"), @@ -87230,6 +166519,10 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["apocalyptic"], &["apocalypse"], &["apocalypse"], + &["appointed"], + &["appointing"], + &["appointment"], + &["appoints"], &["apologetic"], &["apologized"], &["apologizing"], @@ -87246,7 +166539,8 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["apologists"], &["apologetic"], &["apologizing"], - &["upon"], + &["upon", "apron"], + &["apportionable"], &["apostles"], &["apostles"], &["apostrophe"], @@ -87256,7 +166550,7 @@ pub static WORD_APO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["apostrophe"], &["apostrophe"], &["apostrophe"], - &["apostrophe"], + &["apostrophe", "apostrophes"], ], range: 1..=9, }; @@ -87268,18 +166562,49 @@ static WORD_APL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_APL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ha"), dictgen::InsensitiveStr::Ascii("habet"), dictgen::InsensitiveStr::Ascii("ication"), + dictgen::InsensitiveStr::Ascii("ications"), dictgen::InsensitiveStr::Ascii("ied"), + dictgen::InsensitiveStr::Ascii("itude"), + dictgen::InsensitiveStr::Ascii("licatin"), + 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("yed"), ], values: &[ + &["alpha"], &["alphabet"], &["application"], - &["applied"], &["applications"], + &["applied"], + &["amplitude", "aptitude"], + &["application"], + &["application"], + &["applications"], + &["applied"], + &["applies"], + &["apply"], + &["applying"], + &["applied"], ], - range: 3..=9, + range: 2..=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("logue")], + values: &[&["epilogue"]], + range: 5..=5, }; static WORD_APE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87289,11 +166614,49 @@ static WORD_APE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_APE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ar"), + dictgen::InsensitiveStr::Ascii("ared"), + 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("rutre"), + dictgen::InsensitiveStr::Ascii("ture"), ], - values: &[&["apennines"], &["aperture"]], - range: 5..=5, + values: &[ + &["appear"], + &["appeared"], + &["appends"], + &["append"], + &["appendage"], + &["appended"], + &["appender"], + &["appendices"], + &["appending"], + &["appendix"], + &["apennines"], + &["apertures"], + &["aperture"], + &["aperture"], + ], + 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 { @@ -87303,9 +166666,12 @@ static WORD_APA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("rent"), + dictgen::InsensitiveStr::Ascii("rently"), dictgen::InsensitiveStr::Ascii("rment"), dictgen::InsensitiveStr::Ascii("rtheied"), dictgen::InsensitiveStr::Ascii("rthide"), @@ -87314,9 +166680,12 @@ pub static WORD_APA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("rtmet"), ], values: &[ + &["apache"], &["apocalypse"], &["apocalyptic"], + &["adapted"], &["apparent"], + &["apparently"], &["apartment"], &["apartheid"], &["apartheid"], @@ -87324,7 +166693,28 @@ pub static WORD_APA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["apartments"], &["apartments"], ], - range: 4..=8, + 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("vid"), + ], + values: &[ + &["apache"], + &["and"], + &["another", "other", "mother"], + &["avoid"], + ], + range: 2..=4, }; static WORD_AN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87340,7 +166730,7 @@ static WORD_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_ANE_NODE), None, Some(&WORD_ANG_NODE), - None, + Some(&WORD_ANH_NODE), Some(&WORD_ANI_NODE), None, None, @@ -87368,30 +166758,58 @@ static WORD_ANY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ANY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("awy"), + dictgen::InsensitiveStr::Ascii("hing"), dictgen::InsensitiveStr::Ascii("hting"), dictgen::InsensitiveStr::Ascii("hwere"), + 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"), ], values: &[ + &["anyway"], + &["anything"], &["anything"], &["anywhere"], + &["anymore"], &["anonymity"], &["anonymous"], &["anyones"], &["anyones"], &["anyones"], + &["another"], &["anything"], &["anything"], + &["anything"], + &["anything"], + &["anytime"], + &["anything"], + &["anything"], + &["anything"], + &["anything"], + &["anything"], + &["anything"], + &["anywhere"], &["anyways"], ], - range: 4..=6, + range: 3..=6, }; static WORD_ANX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87412,13 +166830,26 @@ static WORD_ANW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ANW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ay"), + dictgen::InsensitiveStr::Ascii("ays"), + 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: &[&["answered"], &["answering"], &["answers"], &["anyways"]], - range: 4..=6, + values: &[ + &["anyway"], + &["anyway"], + &["anywhere"], + &["answer"], + &["answered"], + &["answering"], + &["answers"], + &["anyways"], + ], + range: 2..=6, }; static WORD_ANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87429,106 +166860,152 @@ static WORD_ANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ANU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("al"), + dictgen::InsensitiveStr::Ascii("ally"), dictgen::InsensitiveStr::Ascii("glar"), dictgen::InsensitiveStr::Ascii("lled"), + dictgen::InsensitiveStr::Ascii("mber"), + ], + values: &[ + &["annual"], + &["annually"], + &["angular"], + &["annulled"], + &["number"], ], - values: &[&["annual"], &["angular"], &["annulled"]], range: 2..=4, }; static WORD_ANT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ANT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ANT_CHILDREN), value: None, }; -pub static WORD_ANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aganist"), - dictgen::InsensitiveStr::Ascii("aganistic"), - dictgen::InsensitiveStr::Ascii("agnoist"), - dictgen::InsensitiveStr::Ascii("agonisic"), - dictgen::InsensitiveStr::Ascii("agonisitc"), - dictgen::InsensitiveStr::Ascii("agonisitic"), - dictgen::InsensitiveStr::Ascii("agonistc"), - dictgen::InsensitiveStr::Ascii("agonostic"), - dictgen::InsensitiveStr::Ascii("agonstic"), - dictgen::InsensitiveStr::Ascii("arcitca"), - dictgen::InsensitiveStr::Ascii("arctia"), - dictgen::InsensitiveStr::Ascii("arctida"), - dictgen::InsensitiveStr::Ascii("artic"), - dictgen::InsensitiveStr::Ascii("ennaes"), - dictgen::InsensitiveStr::Ascii("ennea"), - dictgen::InsensitiveStr::Ascii("ennna"), - dictgen::InsensitiveStr::Ascii("hromorphization"), - dictgen::InsensitiveStr::Ascii("hropolgist"), - dictgen::InsensitiveStr::Ascii("hropolgy"), - dictgen::InsensitiveStr::Ascii("hropoloy"), - dictgen::InsensitiveStr::Ascii("hropoly"), - dictgen::InsensitiveStr::Ascii("ibiodic"), - dictgen::InsensitiveStr::Ascii("ibiodics"), - dictgen::InsensitiveStr::Ascii("ibioitcs"), - dictgen::InsensitiveStr::Ascii("ibioitic"), - dictgen::InsensitiveStr::Ascii("ibiotcs"), - dictgen::InsensitiveStr::Ascii("ibioticos"), - dictgen::InsensitiveStr::Ascii("ibitoic"), - dictgen::InsensitiveStr::Ascii("ibitoics"), - dictgen::InsensitiveStr::Ascii("iboitic"), - dictgen::InsensitiveStr::Ascii("iboitics"), - dictgen::InsensitiveStr::Ascii("icapate"), - dictgen::InsensitiveStr::Ascii("icapated"), - dictgen::InsensitiveStr::Ascii("iciapte"), - dictgen::InsensitiveStr::Ascii("iciapted"), - dictgen::InsensitiveStr::Ascii("iciaption"), - dictgen::InsensitiveStr::Ascii("icipacion"), - dictgen::InsensitiveStr::Ascii("icipare"), - dictgen::InsensitiveStr::Ascii("icipatin"), - dictgen::InsensitiveStr::Ascii("icipato"), - dictgen::InsensitiveStr::Ascii("icipe"), - dictgen::InsensitiveStr::Ascii("icuated"), - dictgen::InsensitiveStr::Ascii("idepressents"), - dictgen::InsensitiveStr::Ascii("idepresssants"), - dictgen::InsensitiveStr::Ascii("iobitics"), - dictgen::InsensitiveStr::Ascii("iquae"), - dictgen::InsensitiveStr::Ascii("iquaited"), - dictgen::InsensitiveStr::Ascii("iquited"), - dictgen::InsensitiveStr::Ascii("iqvated"), - dictgen::InsensitiveStr::Ascii("isipate"), - dictgen::InsensitiveStr::Ascii("isipated"), - dictgen::InsensitiveStr::Ascii("isipation"), - dictgen::InsensitiveStr::Ascii("isocail"), - dictgen::InsensitiveStr::Ascii("isosial"), - dictgen::InsensitiveStr::Ascii("ivirs"), - dictgen::InsensitiveStr::Ascii("iviurs"), - dictgen::InsensitiveStr::Ascii("ivrius"), - dictgen::InsensitiveStr::Ascii("ivuris"), - dictgen::InsensitiveStr::Ascii("oganist"), - dictgen::InsensitiveStr::Ascii("ogonistic"), - dictgen::InsensitiveStr::Ascii("ractica"), - dictgen::InsensitiveStr::Ascii("rhopology"), - dictgen::InsensitiveStr::Ascii("rophology"), + dictgen::InsensitiveStr::Ascii("actica"), + dictgen::InsensitiveStr::Ascii("hopology"), + dictgen::InsensitiveStr::Ascii("ophology"), + dictgen::InsensitiveStr::Ascii("y"), ], values: &[ - &["antagonist"], - &["antagonistic"], - &["antagonist"], - &["antagonistic"], - &["antagonistic"], - &["antagonistic"], - &["antagonistic"], - &["antagonist"], - &["antagonist"], &["antarctica"], - &["antarctica"], - &["antarctica"], - &["antarctic"], - &["antennas"], - &["antenna"], - &["antenna"], - &["anthropomorphization"], - &["anthropologist"], - &["anthropology"], &["anthropology"], &["anthropology"], + &["entry"], + ], + range: 1..=8, +}; + +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("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"], @@ -87549,6 +167026,7 @@ pub static WORD_ANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["anticipation"], &["anticipation"], &["anticipate"], + &["anticipate"], &["antiquated"], &["antidepressants"], &["antidepressants"], @@ -87566,13 +167044,103 @@ pub static WORD_ANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["antivirus"], &["antivirus"], &["antivirus"], - &["antagonist"], - &["antagonistic"], - &["antarctica"], + ], + 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: 5..=15, + 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 { @@ -87587,6 +167155,13 @@ pub static WORD_ANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("ynchronous"), ], values: &[ &["nasalisation"], @@ -87594,8 +167169,15 @@ pub static WORD_ANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["ancestors"], &["answered"], &["answers"], + &["answer"], + &["answered"], + &["answering"], + &["answers"], + &["answering"], + &["answers"], + &["asynchronous"], ], - range: 4..=9, + range: 4..=10, }; static WORD_ANR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87604,9 +167186,12 @@ static WORD_ANR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ANR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("achist")], - values: &[&["anarchist"]], - range: 6..=6, + 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 { @@ -87630,6 +167215,8 @@ pub static WORD_ANO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("erxia"), dictgen::InsensitiveStr::Ascii("erxic"), dictgen::InsensitiveStr::Ascii("hter"), + dictgen::InsensitiveStr::Ascii("logon"), + dictgen::InsensitiveStr::Ascii("mally"), dictgen::InsensitiveStr::Ascii("misity"), dictgen::InsensitiveStr::Ascii("molies"), dictgen::InsensitiveStr::Ascii("molous"), @@ -87642,23 +167229,41 @@ pub static WORD_ANO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nmyous"), dictgen::InsensitiveStr::Ascii("nmyously"), dictgen::InsensitiveStr::Ascii("nomously"), + dictgen::InsensitiveStr::Ascii("nonymous"), + dictgen::InsensitiveStr::Ascii("nther"), dictgen::InsensitiveStr::Ascii("nymos"), dictgen::InsensitiveStr::Ascii("nymosly"), + dictgen::InsensitiveStr::Ascii("nymouse"), dictgen::InsensitiveStr::Ascii("nymousny"), dictgen::InsensitiveStr::Ascii("nymousy"), dictgen::InsensitiveStr::Ascii("nymoys"), + dictgen::InsensitiveStr::Ascii("nyms"), + dictgen::InsensitiveStr::Ascii("nymus"), dictgen::InsensitiveStr::Ascii("reixa"), dictgen::InsensitiveStr::Ascii("rexiac"), dictgen::InsensitiveStr::Ascii("rexica"), + dictgen::InsensitiveStr::Ascii("rmal"), + dictgen::InsensitiveStr::Ascii("rmalies"), + dictgen::InsensitiveStr::Ascii("rmally"), + dictgen::InsensitiveStr::Ascii("rmaly"), + dictgen::InsensitiveStr::Ascii("ter"), + dictgen::InsensitiveStr::Ascii("the"), + dictgen::InsensitiveStr::Ascii("thers"), + dictgen::InsensitiveStr::Ascii("unce"), dictgen::InsensitiveStr::Ascii("unced"), dictgen::InsensitiveStr::Ascii("uncement"), + dictgen::InsensitiveStr::Ascii("unt"), dictgen::InsensitiveStr::Ascii("xeria"), dictgen::InsensitiveStr::Ascii("xeric"), + dictgen::InsensitiveStr::Ascii("ying"), + dictgen::InsensitiveStr::Ascii("ymous"), ], values: &[ &["anorexia"], &["anorexic"], &["another"], + &["analogon"], + &["anomaly"], &["animosity"], &["anomalies"], &["anomalous"], @@ -87672,112 +167277,187 @@ pub static WORD_ANO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["anonymously"], &["anonymously"], &["anonymous"], + &["another"], + &["anonymous"], + &["anonymously"], + &["anonymous"], &["anonymously"], &["anonymously"], &["anonymously"], - &["anonymously"], + &["anonymous"], + &["anonymous"], &["anorexia"], &["anorexic"], &["anorexia"], + &["abnormal"], + &["anomalies"], + &["abnormally"], + &["abnormally"], + &["another"], + &["another"], + &["another"], + &["announce"], &["announced"], &["announcement"], + &["amount"], &["anorexia"], &["anorexic"], + &["annoying"], + &["anonymous"], ], - range: 4..=8, + range: 3..=8, }; static WORD_ANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ANN_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ANN_CHILDREN), value: None, }; -pub static WORD_ANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_ANN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + Some(&WORD_ANNA_NODE), + None, + None, + None, + None, + None, + None, + Some(&WORD_ANNH_NODE), + Some(&WORD_ANNI_NODE), + None, + None, + None, + None, + None, + 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("hiliation"), - dictgen::InsensitiveStr::Ascii("ihalated"), - dictgen::InsensitiveStr::Ascii("ihalition"), - dictgen::InsensitiveStr::Ascii("ihilaton"), - dictgen::InsensitiveStr::Ascii("ihilatron"), - dictgen::InsensitiveStr::Ascii("ihilited"), - dictgen::InsensitiveStr::Ascii("ihliated"), - dictgen::InsensitiveStr::Ascii("ihliation"), - dictgen::InsensitiveStr::Ascii("ilihate"), - dictgen::InsensitiveStr::Ascii("ilihated"), - dictgen::InsensitiveStr::Ascii("ilihation"), - dictgen::InsensitiveStr::Ascii("iverary"), - dictgen::InsensitiveStr::Ascii("iversairy"), - dictgen::InsensitiveStr::Ascii("iversarry"), - dictgen::InsensitiveStr::Ascii("iversay"), - dictgen::InsensitiveStr::Ascii("iversery"), - dictgen::InsensitiveStr::Ascii("iversiary"), - dictgen::InsensitiveStr::Ascii("iversry"), - dictgen::InsensitiveStr::Ascii("iversy"), - dictgen::InsensitiveStr::Ascii("oint"), - dictgen::InsensitiveStr::Ascii("ointed"), - dictgen::InsensitiveStr::Ascii("ointing"), - dictgen::InsensitiveStr::Ascii("oints"), - dictgen::InsensitiveStr::Ascii("onceurs"), - dictgen::InsensitiveStr::Ascii("onymouse"), - dictgen::InsensitiveStr::Ascii("ouced"), - dictgen::InsensitiveStr::Ascii("oucenment"), - dictgen::InsensitiveStr::Ascii("oucne"), - dictgen::InsensitiveStr::Ascii("oucnement"), - dictgen::InsensitiveStr::Ascii("oucnements"), - dictgen::InsensitiveStr::Ascii("oucners"), - dictgen::InsensitiveStr::Ascii("oucnes"), - dictgen::InsensitiveStr::Ascii("oucning"), - dictgen::InsensitiveStr::Ascii("ounceing"), - dictgen::InsensitiveStr::Ascii("ouncemet"), - dictgen::InsensitiveStr::Ascii("ouncemnet"), - dictgen::InsensitiveStr::Ascii("ouncemnt"), - dictgen::InsensitiveStr::Ascii("ouncemnts"), - dictgen::InsensitiveStr::Ascii("ouncents"), - dictgen::InsensitiveStr::Ascii("ounched"), - dictgen::InsensitiveStr::Ascii("oyingy"), - dictgen::InsensitiveStr::Ascii("oymous"), - dictgen::InsensitiveStr::Ascii("oymously"), - dictgen::InsensitiveStr::Ascii("oynace"), - dictgen::InsensitiveStr::Ascii("tenas"), - dictgen::InsensitiveStr::Ascii("ualy"), - dictgen::InsensitiveStr::Ascii("uled"), - dictgen::InsensitiveStr::Ascii("yoance"), - dictgen::InsensitiveStr::Ascii("yoingly"), + 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("ncement"), + dictgen::InsensitiveStr::Ascii("nceurs"), + dictgen::InsensitiveStr::Ascii("nymous"), + dictgen::InsensitiveStr::Ascii("nymouse"), + dictgen::InsensitiveStr::Ascii("taion"), + dictgen::InsensitiveStr::Ascii("taions"), + dictgen::InsensitiveStr::Ascii("ted"), + dictgen::InsensitiveStr::Ascii("ther"), + dictgen::InsensitiveStr::Ascii("uce"), + dictgen::InsensitiveStr::Ascii("uced"), + dictgen::InsensitiveStr::Ascii("ucement"), + 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("yingy"), + dictgen::InsensitiveStr::Ascii("ymous"), + dictgen::InsensitiveStr::Ascii("ymously"), + dictgen::InsensitiveStr::Ascii("ynace"), ], values: &[ - &["annihilation"], - &["annihilated"], - &["annihilation"], - &["annihilation"], - &["annihilation"], - &["annihilated"], - &["annihilated"], - &["annihilation"], - &["annihilated"], - &["annihilated"], - &["annihilation"], - &["anniversary"], - &["anniversary"], - &["anniversary"], - &["anniversary"], - &["anniversary"], - &["anniversary"], - &["anniversary"], - &["anniversary"], + &["annotation"], &["anoint"], &["anointed"], &["anointing"], &["anoints"], + &["announcement"], &["announcers"], &["anonymous"], + &["anonymous"], + &["annotation"], + &["annotations"], + &["annotated"], + &["another"], + &["announce"], &["announced"], + &["announcement"], &["announcements"], + &["announces"], + &["announcing"], &["announce"], &["announcement"], &["announcements"], &["announcers"], &["announces"], &["announcing"], + &["annoying"], &["announcing"], &["announcements"], &["announcements"], @@ -87785,17 +167465,98 @@ pub static WORD_ANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["announcements"], &["announces"], &["announce"], + &["announcement"], + &["announcements"], + &["announced"], + &["announcement"], + &["announcements"], &["annoyingly"], &["anonymous"], &["anonymously"], &["annoyance"], - &["antennas"], - &["annually"], - &["annulled"], - &["annoyance"], - &["annoyingly"], ], - range: 4..=10, + range: 3..=9, +}; + +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("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"], + &["anniversary"], + &["anniversary"], + &["anniversary"], + &["anniversary"], + &["anniversary"], + &["anniversary"], + &["anniversary"], + &["anniversary"], + ], + range: 5..=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_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("y"), + dictgen::InsensitiveStr::Ascii("yed"), + dictgen::InsensitiveStr::Ascii("ying"), + dictgen::InsensitiveStr::Ascii("ys"), + ], + values: &[ + &["annoy", "any"], + &["annoyed"], + &["annoying"], + &["annoys", "any"], + ], + range: 1..=4, }; static WORD_ANM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87821,9 +167582,20 @@ pub static WORD_ANL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"]], - range: 5..=6, + values: &[ + &["analyses"], + &["analytics"], + &["angle"], + &["only"], + &["analysis"], + &["analyzing"], + ], + range: 1..=6, }; static WORD_ANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87835,42 +167607,101 @@ pub static WORD_ANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ 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("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: &[ &["ancient"], &["ancients"], + &["and"], &["annihilation"], + &["animating"], &["animate"], + &["animator"], + &["animators"], + &["animation"], + &["animations"], + &["animator"], + &["animators"], &["animate"], + &["animator", "animation"], + &["animation"], + &["animatronic"], + &["animate"], + &["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: 4..=12, + 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 { @@ -87900,7 +167731,7 @@ pub static WORD_ANG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict static WORD_ANE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ANE_CHILDREN), - value: None, + value: Some(&["and"]), }; pub static WORD_ANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { @@ -87929,6 +167760,8 @@ pub static WORD_ANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("stheisa"), dictgen::InsensitiveStr::Ascii("sthetia"), dictgen::InsensitiveStr::Ascii("sthisia"), + dictgen::InsensitiveStr::Ascii("vironment"), + dictgen::InsensitiveStr::Ascii("vironments"), ], values: &[ &["anecdotally"], @@ -87955,8 +167788,10 @@ pub static WORD_ANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["anesthesia"], &["anesthesia"], &["anesthesia"], + &["environment"], + &["environments"], ], - range: 5..=9, + range: 5..=10, }; static WORD_AND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -87967,6 +167802,8 @@ static WORD_AND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("oirds"), dictgen::InsensitiveStr::Ascii("orid"), dictgen::InsensitiveStr::Ascii("orids"), @@ -87976,12 +167813,16 @@ pub static WORD_AND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("rois"), ], values: &[ &["and"], + &["handlers", "antlers"], + &["android"], &["androids"], &["android"], &["androids"], @@ -87991,11 +167832,13 @@ pub static WORD_AND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["androgyny"], &["androids"], &["androids"], + &["androidextras"], &["androids"], &["androids"], + &["android"], &["androids"], ], - range: 1..=8, + range: 1..=9, }; static WORD_ANC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88005,24 +167848,36 @@ static WORD_ANC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ANC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("apsulate"), 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("estore"), + dictgen::InsensitiveStr::Ascii("estores"), dictgen::InsensitiveStr::Ascii("estory"), + dictgen::InsensitiveStr::Ascii("hord"), dictgen::InsensitiveStr::Ascii("illiary"), dictgen::InsensitiveStr::Ascii("inets"), ], values: &[ + &["encapsulate"], &["anecdotal"], &["anecdotally"], &["anecdote"], &["anecdotes"], &["ancient"], &["ancients"], + &["ancestor"], + &["ancestors"], + &["ancestor"], + &["ancestors"], &["ancestry"], + &["anchored"], &["ancillary"], &["ancients"], ], @@ -88041,126 +167896,400 @@ pub static WORD_ANB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_ANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ANA_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ANA_CHILDREN), value: None, }; -pub static WORD_ANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("christ"), - dictgen::InsensitiveStr::Ascii("lagous"), - dictgen::InsensitiveStr::Ascii("lgoue"), - dictgen::InsensitiveStr::Ascii("lisys"), - dictgen::InsensitiveStr::Ascii("litic"), - dictgen::InsensitiveStr::Ascii("litical"), - dictgen::InsensitiveStr::Ascii("litycal"), - dictgen::InsensitiveStr::Ascii("litycs"), - dictgen::InsensitiveStr::Ascii("loge"), - dictgen::InsensitiveStr::Ascii("logeous"), - dictgen::InsensitiveStr::Ascii("louge"), - dictgen::InsensitiveStr::Ascii("lsyt"), - dictgen::InsensitiveStr::Ascii("ltyics"), - dictgen::InsensitiveStr::Ascii("lyes"), - dictgen::InsensitiveStr::Ascii("lyitcal"), - dictgen::InsensitiveStr::Ascii("lyitcs"), - dictgen::InsensitiveStr::Ascii("lyseas"), - dictgen::InsensitiveStr::Ascii("lysees"), - dictgen::InsensitiveStr::Ascii("lyseles"), - dictgen::InsensitiveStr::Ascii("lysens"), - dictgen::InsensitiveStr::Ascii("lyseras"), - dictgen::InsensitiveStr::Ascii("lyseres"), - dictgen::InsensitiveStr::Ascii("lysie"), - dictgen::InsensitiveStr::Ascii("lysise"), - dictgen::InsensitiveStr::Ascii("lysised"), - dictgen::InsensitiveStr::Ascii("lysises"), - dictgen::InsensitiveStr::Ascii("lysisto"), - dictgen::InsensitiveStr::Ascii("lysit"), - dictgen::InsensitiveStr::Ascii("lyste"), - dictgen::InsensitiveStr::Ascii("lystes"), - dictgen::InsensitiveStr::Ascii("lystics"), - dictgen::InsensitiveStr::Ascii("lysze"), - dictgen::InsensitiveStr::Ascii("lyticals"), - dictgen::InsensitiveStr::Ascii("lyts"), - dictgen::InsensitiveStr::Ascii("lzye"), - dictgen::InsensitiveStr::Ascii("lzyed"), - dictgen::InsensitiveStr::Ascii("lzying"), - dictgen::InsensitiveStr::Ascii("olgue"), - dictgen::InsensitiveStr::Ascii("rchim"), - dictgen::InsensitiveStr::Ascii("rchisim"), - dictgen::InsensitiveStr::Ascii("rchistes"), - dictgen::InsensitiveStr::Ascii("rchistm"), - dictgen::InsensitiveStr::Ascii("rchiszm"), - dictgen::InsensitiveStr::Ascii("rchsim"), - dictgen::InsensitiveStr::Ascii("rchsits"), - dictgen::InsensitiveStr::Ascii("ylse"), - dictgen::InsensitiveStr::Ascii("ylses"), - dictgen::InsensitiveStr::Ascii("ylsis"), - dictgen::InsensitiveStr::Ascii("ylst"), - dictgen::InsensitiveStr::Ascii("ylsts"), - dictgen::InsensitiveStr::Ascii("yltical"), - dictgen::InsensitiveStr::Ascii("yltics"), - dictgen::InsensitiveStr::Ascii("ylze"), - dictgen::InsensitiveStr::Ascii("ylzed"), - dictgen::InsensitiveStr::Ascii("ylzing"), + dictgen::InsensitiveStr::Ascii("lse"), + dictgen::InsensitiveStr::Ascii("lses"), + dictgen::InsensitiveStr::Ascii("lsis"), + dictgen::InsensitiveStr::Ascii("lst"), + dictgen::InsensitiveStr::Ascii("lsts"), + dictgen::InsensitiveStr::Ascii("ltical"), + dictgen::InsensitiveStr::Ascii("ltics"), + dictgen::InsensitiveStr::Ascii("lze"), + dictgen::InsensitiveStr::Ascii("lzed"), + dictgen::InsensitiveStr::Ascii("lzing"), ], values: &[ + &["analyse"], + &["analyses"], + &["analysis"], + &["analyst"], + &["analysts"], + &["analytical"], + &["analytics"], + &["analyze"], + &["analyzed"], + &["analyzing"], + ], + range: 3..=6, +}; + +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("chsim"), + dictgen::InsensitiveStr::Ascii("chsits"), + dictgen::InsensitiveStr::Ascii("quism"), + dictgen::InsensitiveStr::Ascii("quist"), + ], + values: &[ + &["anarchism"], + &["anarchism"], + &["anarchists"], + &["anarchism"], + &["anarchism"], + &["anarchism"], + &["anarchists"], + &["anarchism"], &["anarchist"], + ], + 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("ying"), + ], + values: &[&["analyze"], &["analyzed"], &["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("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("sises"), + 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("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"], + &["analytical"], + &["analytics"], + &["analyser"], + &["analyses"], + &["analyses"], + &["analyses"], + &["analyses"], + &["analyses"], + &["analyses"], + &["analyse"], + &["analyses", "analysis"], + &["analyses"], + &["analyses"], + &["analyses"], + &["analysts"], + &["analyst"], + &["analyse"], + &["analysts"], + &["analysts"], + &["analysis"], + &["analysis"], + &["analyse"], + &["analytical", "analytically"], + &["analytics"], + &["analytically"], + &["analytically"], + &["analyst"], + &["analyzer"], + &["analysis", "analyzes", "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("yis"), + dictgen::InsensitiveStr::Ascii("yt"), + ], + values: &[&["analysis"], &["analyst"]], + range: 2..=3, +}; + +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"], - &["analytical"], - &["analytics"], - &["analogue"], - &["analogous"], - &["analogue"], - &["analyst"], - &["analytics"], - &["analyse"], - &["analytical"], - &["analytics"], - &["analyses"], - &["analyses"], - &["analyses"], - &["analyses"], - &["analyses"], - &["analyses"], - &["analyse"], - &["analyses"], - &["analyses"], - &["analyses"], - &["analysts"], - &["analyst"], - &["analyse"], - &["analysts"], - &["analysts"], - &["analyse"], - &["analytics"], - &["analyst"], - &["analyze"], - &["analyzed"], - &["analyzing"], - &["analogue"], - &["anarchism"], - &["anarchism"], - &["anarchists"], - &["anarchism"], - &["anarchism"], - &["anarchism"], - &["anarchists"], - &["analyse"], - &["analyses"], - &["analysis"], - &["analyst"], - &["analysts"], + &["analytically"], + &["analytically"], &["analytical"], &["analytics"], &["analyze"], &["analyzed"], + &["analyzer"], + &["analyzes"], &["analyzing"], ], - range: 4..=8, + 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 { @@ -88172,10 +168301,10 @@ static WORD_AM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_AMA_NODE), Some(&WORD_AMB_NODE), None, - None, + Some(&WORD_AMD_NODE), Some(&WORD_AME_NODE), None, - None, + Some(&WORD_AMG_NODE), None, Some(&WORD_AMI_NODE), None, @@ -88205,10 +168334,18 @@ static WORD_AMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], ], - values: &[&["ambulance"], &["among"], &["ammunition"]], range: 2..=6, }; @@ -88255,8 +168392,10 @@ pub static WORD_AMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ 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("hedamines"), dictgen::InsensitiveStr::Ascii("hetamenes"), @@ -88269,14 +168408,19 @@ pub static WORD_AMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("hetmaine"), dictgen::InsensitiveStr::Ascii("hetmaines"), dictgen::InsensitiveStr::Ascii("ilfy"), + dictgen::InsensitiveStr::Ascii("lifer"), dictgen::InsensitiveStr::Ascii("lifiy"), dictgen::InsensitiveStr::Ascii("lifly"), + dictgen::InsensitiveStr::Ascii("lifyer"), + dictgen::InsensitiveStr::Ascii("ty"), ], values: &[ &["amphetamine"], &["amphetamines"], + &["ampersands"], &["amphetamine"], &["amphetamines"], + &["emphasis"], &["amphetamines"], &["amphetamines"], &["amphetamines"], @@ -88289,10 +168433,13 @@ pub static WORD_AMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["amphetamines"], &["amphetamines"], &["amplify"], + &["amplifier"], &["amplify"], &["amplify"], + &["amplifier"], + &["empty"], ], - range: 4..=9, + range: 2..=9, }; static WORD_AMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88304,20 +168451,38 @@ pub static WORD_AMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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"], - &["amongst"], - &["amongst"], &["among"], &["amongst"], + &["amongst"], + &["amongst"], + &["amount"], + &["amount"], + &["amounts"], + &["among"], + &["amongst"], + &["amount"], + &["amount"], + &["amounts"], + &["amounts"], ], - range: 3..=9, + range: 2..=9, }; static WORD_AMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88330,9 +168495,10 @@ pub static WORD_AMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("eisa"), dictgen::InsensitiveStr::Ascii("estry"), dictgen::InsensitiveStr::Ascii("sety"), + dictgen::InsensitiveStr::Ascii("y"), ], - values: &[&["amnesia"], &["amnesty"], &["amnesty"]], - range: 4..=5, + values: &[&["amnesia"], &["amnesty"], &["amnesty"], &["many"]], + range: 1..=5, }; static WORD_AMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88344,18 +168510,32 @@ pub static WORD_AMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], ], @@ -88384,10 +168564,25 @@ static WORD_AMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"], &["animosity"]], - range: 6..=6, + 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 { @@ -88397,11 +168592,13 @@ static WORD_AME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_AME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("ndement"), dictgen::InsensitiveStr::Ascii("ndmant"), dictgen::InsensitiveStr::Ascii("ndmants"), dictgen::InsensitiveStr::Ascii("ndmends"), dictgen::InsensitiveStr::Ascii("ndmenters"), dictgen::InsensitiveStr::Ascii("ndmet"), + dictgen::InsensitiveStr::Ascii("ned"), dictgen::InsensitiveStr::Ascii("nsia"), dictgen::InsensitiveStr::Ascii("nsty"), dictgen::InsensitiveStr::Ascii("rcia"), @@ -88426,11 +168623,13 @@ pub static WORD_AME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ythst"), ], values: &[ + &["amendment"], &["amendment"], &["amendments"], &["amendments"], &["amendments"], &["amendments"], + &["amended", "amend"], &["amnesia"], &["amnesty"], &["america"], @@ -88454,7 +168653,18 @@ pub static WORD_AME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["amethyst"], &["amethyst"], ], - range: 4..=9, + range: 3..=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 { @@ -88470,10 +168680,20 @@ pub static WORD_AMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("assedor"), dictgen::InsensitiveStr::Ascii("assidor"), dictgen::InsensitiveStr::Ascii("assodor"), + dictgen::InsensitiveStr::Ascii("edded"), + dictgen::InsensitiveStr::Ascii("ibuity"), + 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: &[ &["ambassador"], @@ -88482,12 +168702,22 @@ pub static WORD_AMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["ambassador"], &["ambassador"], &["ambassador"], + &["embedded"], &["ambiguity"], + &["ambiguous"], + &["ambiguous"], + &["ambiguous"], + &["ambiguity"], + &["ambiguous"], + &["ambitious"], &["ambulance"], &["ambiguity"], + &["ambiguity"], &["ambulance"], + &["ambulance"], + &["ambulances"], ], - range: 6..=8, + range: 5..=8, }; static WORD_AMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88497,6 +168727,8 @@ static WORD_AMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("rgeddon"), dictgen::InsensitiveStr::Ascii("tersu"), @@ -88506,8 +168738,11 @@ pub static WORD_AMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("teus"), dictgen::InsensitiveStr::Ascii("tuer"), dictgen::InsensitiveStr::Ascii("ture"), + dictgen::InsensitiveStr::Ascii("zaing"), ], values: &[ + &["amazing"], + &["amazingly"], &["amalgamated"], &["armageddon"], &["amateurs"], @@ -88516,7 +168751,8 @@ pub static WORD_AMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["amateurs"], &["amateurs"], &["amateur"], - &["armature"], + &["armature", "amateur"], + &["amazing"], ], range: 4..=8, }; @@ -88527,14 +168763,14 @@ static WORD_AL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ - None, + Some(&WORD_ALA_NODE), Some(&WORD_ALB_NODE), Some(&WORD_ALC_NODE), Some(&WORD_ALD_NODE), Some(&WORD_ALE_NODE), None, Some(&WORD_ALG_NODE), - None, + Some(&WORD_ALH_NODE), Some(&WORD_ALI_NODE), None, None, @@ -88548,13 +168784,24 @@ static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_ALS_NODE), Some(&WORD_ALT_NODE), Some(&WORD_ALU_NODE), - None, + Some(&WORD_ALV_NODE), Some(&WORD_ALW_NODE), None, - 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, @@ -88562,11 +168809,47 @@ static WORD_ALW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("auys"), + dictgen::InsensitiveStr::Ascii("ay"), dictgen::InsensitiveStr::Ascii("yas"), ], - values: &[&["always"], &["always"]], - range: 3..=3, + values: &[ + &["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 { @@ -88576,6 +168859,7 @@ static WORD_ALU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -88583,146 +168867,318 @@ pub static WORD_ALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("sion"), ], values: &[ + &["value"], &["aluminium"], &["aluminium"], &["aluminium"], &["aluminum"], - &["allusion"], + &["allusion", "illusion"], ], - range: 4..=7, + range: 1..=7, }; static WORD_ALT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ALT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ALT_CHILDREN), value: None, }; -pub static WORD_ALT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("anta"), - dictgen::InsensitiveStr::Ascii("antic"), - dictgen::InsensitiveStr::Ascii("east"), - dictgen::InsensitiveStr::Ascii("eracion"), - dictgen::InsensitiveStr::Ascii("erante"), - dictgen::InsensitiveStr::Ascii("erantive"), - dictgen::InsensitiveStr::Ascii("erantively"), - dictgen::InsensitiveStr::Ascii("erantives"), - dictgen::InsensitiveStr::Ascii("erarion"), - dictgen::InsensitiveStr::Ascii("erating"), - dictgen::InsensitiveStr::Ascii("erato"), - dictgen::InsensitiveStr::Ascii("ernador"), - dictgen::InsensitiveStr::Ascii("ernar"), - dictgen::InsensitiveStr::Ascii("ernater"), - dictgen::InsensitiveStr::Ascii("ernatevly"), - dictgen::InsensitiveStr::Ascii("ernatie"), - dictgen::InsensitiveStr::Ascii("ernatiely"), - dictgen::InsensitiveStr::Ascii("ernatieve"), - dictgen::InsensitiveStr::Ascii("ernativelly"), - dictgen::InsensitiveStr::Ascii("ernativets"), - dictgen::InsensitiveStr::Ascii("ernativley"), - dictgen::InsensitiveStr::Ascii("ernativly"), - dictgen::InsensitiveStr::Ascii("ernativos"), - dictgen::InsensitiveStr::Ascii("ernatley"), - dictgen::InsensitiveStr::Ascii("ernatly"), - dictgen::InsensitiveStr::Ascii("ernatr"), - dictgen::InsensitiveStr::Ascii("ernatve"), - dictgen::InsensitiveStr::Ascii("ernatvely"), - dictgen::InsensitiveStr::Ascii("ernetly"), - dictgen::InsensitiveStr::Ascii("ernitavely"), - dictgen::InsensitiveStr::Ascii("ernitive"), - dictgen::InsensitiveStr::Ascii("ernitively"), - dictgen::InsensitiveStr::Ascii("ernitives"), - dictgen::InsensitiveStr::Ascii("hetes"), - dictgen::InsensitiveStr::Ascii("hetic"), - dictgen::InsensitiveStr::Ascii("heticism"), - dictgen::InsensitiveStr::Ascii("hetics"), - dictgen::InsensitiveStr::Ascii("hought"), - dictgen::InsensitiveStr::Ascii("nerately"), - dictgen::InsensitiveStr::Ascii("ogehter"), - dictgen::InsensitiveStr::Ascii("ogheter"), - dictgen::InsensitiveStr::Ascii("ough"), - dictgen::InsensitiveStr::Ascii("riusm"), - dictgen::InsensitiveStr::Ascii("riustic"), - dictgen::InsensitiveStr::Ascii("ruisim"), - dictgen::InsensitiveStr::Ascii("ruisitc"), - dictgen::InsensitiveStr::Ascii("ruisitic"), - dictgen::InsensitiveStr::Ascii("ruistisch"), - dictgen::InsensitiveStr::Ascii("ruistric"), - dictgen::InsensitiveStr::Ascii("rusim"), - dictgen::InsensitiveStr::Ascii("rusitic"), - dictgen::InsensitiveStr::Ascii("urism"), - dictgen::InsensitiveStr::Ascii("uristic"), + 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("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: &[ - &["atlanta"], - &["atlantic"], - &["atleast"], - &["alteration"], - &["alternate"], - &["alternative"], - &["alternatively"], - &["alternatives"], - &["alteration"], - &["alteration"], - &["alteration"], - &["alternator"], - &["alternator"], - &["alternator"], - &["alternately"], - &["alternatives"], - &["alternately"], - &["alternative"], - &["alternatively"], - &["alternatives"], - &["alternatively"], - &["alternatively"], - &["alternatives"], - &["alternately"], - &["alternately"], - &["alternator"], - &["alternate"], - &["alternately"], - &["alternately"], - &["alternatively"], - &["alternative"], - &["alternatively"], - &["alternatives"], &["athletes"], &["athletic"], &["athleticism"], &["athletics"], &["although"], - &["alternately"], - &["altogether"], - &["altogether"], + &["algorithm"], + &["algorithmic"], + &["algorithmically"], + &["algorithms"], + &["although"], + &["although"], + &["although"], &["although"], - &["altruism"], - &["altruistic"], - &["altruism"], - &["altruistic"], - &["altruistic"], - &["altruistic"], - &["altruistic"], - &["altruism"], - &["altruistic"], - &["altruism"], - &["altruistic"], ], - range: 4..=11, + 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("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("rating"), + dictgen::InsensitiveStr::Ascii("rative"), + dictgen::InsensitiveStr::Ascii("ratives"), + dictgen::InsensitiveStr::Ascii("rato"), + dictgen::InsensitiveStr::Ascii("rior"), + dictgen::InsensitiveStr::Ascii("rnador"), + dictgen::InsensitiveStr::Ascii("rnaive"), + dictgen::InsensitiveStr::Ascii("rnaives"), + dictgen::InsensitiveStr::Ascii("rnar"), + dictgen::InsensitiveStr::Ascii("rnarive"), + dictgen::InsensitiveStr::Ascii("rnarives"), + dictgen::InsensitiveStr::Ascii("rnater"), + dictgen::InsensitiveStr::Ascii("rnatevly"), + dictgen::InsensitiveStr::Ascii("rnatie"), + dictgen::InsensitiveStr::Ascii("rnatiely"), + 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("rnetive"), + dictgen::InsensitiveStr::Ascii("rnetives"), + dictgen::InsensitiveStr::Ascii("rnetly"), + dictgen::InsensitiveStr::Ascii("rnitavely"), + dictgen::InsensitiveStr::Ascii("rnitive"), + dictgen::InsensitiveStr::Ascii("rnitively"), + dictgen::InsensitiveStr::Ascii("rnitives"), + dictgen::InsensitiveStr::Ascii("tnative"), + ], + values: &[ + &["atleast"], + &["alternative"], + &["alteration"], + &["alternate"], + &["alternative"], + &["alternatively"], + &["alternatives"], + &["alteration"], + &["altered"], + &["alteration"], + &["alternative"], + &["alternatives"], + &["alteration"], + &["ulterior"], + &["alternator"], + &["alternative"], + &["alternatives"], + &["alternator"], + &["alternative"], + &["alternatives"], + &["alternator"], + &["alternately"], + &["alternatives"], + &["alternately"], + &["alternative"], + &["alternatively"], + &["alternatively"], + &["alternatives"], + &["alternatively"], + &["alternatively"], + &["alternatively"], + &["alternatives"], + &["alternately"], + &["alternately"], + &["alternator"], + &["alternate", "alternative"], + &["alternately"], + &["alternative"], + &["alternatives"], + &["alternately"], + &["alternatively"], + &["alternative"], + &["alternatively"], + &["alternatives"], + &["alternative"], + ], + range: 3..=10, +}; + +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: None, + 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"]], - range: 1..=2, + values: &[ + &["else", "also", "false"], + &["almost"], + &["also"], + &["already"], + ], + range: 1..=5, }; static WORD_ALR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88732,16 +169188,41 @@ static WORD_ALR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], + &["alright"], &["already"], &["alrighty"], &["alrighty"], @@ -88749,9 +169230,12 @@ pub static WORD_ALR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["alrighty"], &["alrighty"], &["arlington"], + &["alarms"], &["algorithm"], + &["algorithm"], + &["already"], ], - range: 4..=6, + range: 2..=6, }; static WORD_ALP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88761,46 +169245,121 @@ static WORD_ALP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("hapeticaly"), ], - values: &[&["alphabet"], &["alphabet"], &["alphabet"], &["alphabet"]], - range: 4..=7, + values: &[ + &["alphabet"], + &["alphabetic"], + &["alphabetical"], + &["alphabets"], + &["alpha"], + &["alphabet"], + &["alphabetically"], + &["alpha"], + &["alphabet"], + &["alphabet"], + &["alphabetically"], + &["alphabetical"], + &["alphabet"], + &["alphabetically"], + ], + range: 1..=11, }; static WORD_ALO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ALO_CHILDREN), - value: None, + 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("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("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"], &["alcohol"], &["alcoholic"], &["alcoholics"], &["alcoholism"], + &["along"], &["algorithm"], + &["algorithmic"], + &["algorithmically"], + &["algorithms"], + &["algorithm"], + &["algorithmic"], + &["algorithmically"], + &["algorithms"], + &["aligned"], + &["algorithms"], + &["algorithm"], + &["algorithmic"], + &["algorithmically"], &["algorithms"], &["almost"], + &["allows"], + &["algorithm"], + &["also"], &["allotted"], + &["allow"], &["allowed"], &["allowing"], + &["allows"], ], - range: 3..=7, + range: 1..=12, }; static WORD_ALM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -88813,59 +169372,366 @@ pub static WORD_ALM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"]], + values: &[ + &["almighty"], + &["almighty"], + &["almighty"], + &["almost"], + &["almost"], + &["almost"], + ], range: 3..=6, }; static WORD_ALL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ALL_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ALL_CHILDREN), value: None, }; -pub static WORD_ALL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("aince"), - dictgen::InsensitiveStr::Ascii("ainces"), - dictgen::InsensitiveStr::Ascii("edge"), - dictgen::InsensitiveStr::Ascii("edged"), - dictgen::InsensitiveStr::Ascii("edgedly"), - dictgen::InsensitiveStr::Ascii("edgely"), - dictgen::InsensitiveStr::Ascii("edges"), - dictgen::InsensitiveStr::Ascii("egeance"), - dictgen::InsensitiveStr::Ascii("egedely"), - dictgen::InsensitiveStr::Ascii("egedley"), - dictgen::InsensitiveStr::Ascii("egedy"), - dictgen::InsensitiveStr::Ascii("egely"), - dictgen::InsensitiveStr::Ascii("egence"), - dictgen::InsensitiveStr::Ascii("egiancies"), - dictgen::InsensitiveStr::Ascii("egience"), - dictgen::InsensitiveStr::Ascii("egric"), - dictgen::InsensitiveStr::Ascii("egry"), - dictgen::InsensitiveStr::Ascii("eigance"), - dictgen::InsensitiveStr::Ascii("eigances"), - dictgen::InsensitiveStr::Ascii("eivate"), - dictgen::InsensitiveStr::Ascii("ergey"), - dictgen::InsensitiveStr::Ascii("ergisch"), - dictgen::InsensitiveStr::Ascii("ianse"), - dictgen::InsensitiveStr::Ascii("iegance"), - dictgen::InsensitiveStr::Ascii("ievate"), - dictgen::InsensitiveStr::Ascii("igeance"), - dictgen::InsensitiveStr::Ascii("ign"), - dictgen::InsensitiveStr::Ascii("igned"), - dictgen::InsensitiveStr::Ascii("inace"), - dictgen::InsensitiveStr::Ascii("iviate"), - dictgen::InsensitiveStr::Ascii("opone"), - dictgen::InsensitiveStr::Ascii("opones"), - dictgen::InsensitiveStr::Ascii("ready"), - dictgen::InsensitiveStr::Ascii("though"), - dictgen::InsensitiveStr::Ascii("time"), - dictgen::InsensitiveStr::Ascii("together"), + 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")], + values: &[&["application"]], + range: 7..=7, +}; + +static WORD_ALLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ALLO_CHILDREN), + value: None, +}; + +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("caton"), + dictgen::InsensitiveStr::Ascii("catoor"), + dictgen::InsensitiveStr::Ascii("catote"), + dictgen::InsensitiveStr::Ascii("catrd"), + dictgen::InsensitiveStr::Ascii("ced"), + dictgen::InsensitiveStr::Ascii("co"), + dictgen::InsensitiveStr::Ascii("cos"), + dictgen::InsensitiveStr::Ascii("cte"), + dictgen::InsensitiveStr::Ascii("cted"), + 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"), + ], + 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"], + &["allocation"], + &["allocator"], + &["allocate"], + &["allocated"], + &["allocated"], + &["alloc"], + &["allocs"], + &["allocate"], + &["allocated"], + &["allocations"], + &["allocator"], + &["allowed", "aloud"], + &["allows"], + &["alone"], + &["along"], + &["allocates"], + &["allophone"], + &["allophones"], + &["allows"], + &["allotted"], + &["aloud", "allowed"], + &["allowed", "allow", "allows"], + &["allowed", "allow", "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("ows"), + ], + values: &[&["allocate"], &["allocation"], &["allow"], &["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: &[ - &["alliance"], &["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"], @@ -88886,22 +169752,71 @@ pub static WORD_ALL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["alleviate"], &["allergy"], &["allergic"], - &["alliances"], - &["allegiance"], - &["alleviate"], - &["allegiance"], - &["align"], - &["aligned"], - &["alliance"], - &["alleviate"], - &["allophone"], - &["allophones"], - &["already"], - &["although"], - &[], - &["altogether"], ], - range: 3..=9, + 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 { @@ -88911,87 +169826,893 @@ static WORD_ALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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("gnmen"), + dictgen::InsensitiveStr::Ascii("gnmenet"), + dictgen::InsensitiveStr::Ascii("gnmenets"), + 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("sing"), + dictgen::InsensitiveStr::Ascii("ver"), ], values: &[ + &["align"], + &["aliases"], + &["aliases", "alias"], + &["aliases"], &["alienate"], &["alienating"], &["alienating"], + &["aligned", "alighted"], + &["aligned"], &["alignment"], + &["align"], + &["aligned"], + &["aligning"], + &["alignment"], + &["aligns"], + &["alignment"], + &["alignments"], + &["alignment"], + &["aligned"], + &["align"], + &["alignment"], + &["alignment"], + &["alignments"], + &["alignment"], + &["aligns"], + &["alignment"], + &["alignment"], + &["alignment"], + &["alignments"], + &["alignments"], + &["alignment"], + &["alignments"], + &["alignment"], + &["alignment"], + &["alignright"], + &["alike", "likes"], &["alimony"], &["aluminium"], - &["alinement"], + &["aline", "along", "ailing", "sling"], + &["alined"], + &["alining"], + &["alinement", "alinement"], + &["alines", "slings"], + &["alignment"], + &["alignments"], &["alrighty"], + &["aliasing"], + &["alive", "liver", "sliver"], ], - range: 4..=8, + range: 2..=8, }; -static WORD_ALG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ALG_CHILDREN), +static WORD_ALH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ALH_CHILDREN), value: None, }; -pub static WORD_ALG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ALH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("erba"), - dictgen::InsensitiveStr::Ascii("orhitms"), - dictgen::InsensitiveStr::Ascii("orithem"), - dictgen::InsensitiveStr::Ascii("orithems"), - dictgen::InsensitiveStr::Ascii("orithim"), - dictgen::InsensitiveStr::Ascii("orithims"), - dictgen::InsensitiveStr::Ascii("orithmes"), - dictgen::InsensitiveStr::Ascii("orithmns"), - dictgen::InsensitiveStr::Ascii("orithmus"), - dictgen::InsensitiveStr::Ascii("oriths"), - dictgen::InsensitiveStr::Ascii("orithsm"), - dictgen::InsensitiveStr::Ascii("orithum"), - dictgen::InsensitiveStr::Ascii("orithym"), - dictgen::InsensitiveStr::Ascii("orithyms"), - dictgen::InsensitiveStr::Ascii("oritm"), - dictgen::InsensitiveStr::Ascii("oritmes"), - dictgen::InsensitiveStr::Ascii("oritmos"), - dictgen::InsensitiveStr::Ascii("oritms"), - dictgen::InsensitiveStr::Ascii("orthim"), - dictgen::InsensitiveStr::Ascii("orthims"), - dictgen::InsensitiveStr::Ascii("ortihm"), - dictgen::InsensitiveStr::Ascii("ortihms"), - dictgen::InsensitiveStr::Ascii("orythims"), - dictgen::InsensitiveStr::Ascii("orythms"), + 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"), ], values: &[ - &["algebra"], + &["alpha"], + &["alphabet"], + &["alphabetical"], + &["alphabetically"], + &["alphabetically"], + &["alphabets"], + &["alphabet"], + &["alphabetical"], + &["alphabetically"], + &["alphabetically"], + &["alphabets"], + &["although"], + ], + range: 1..=10, +}; + +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, + None, + None, + None, + None, + None, + None, + None, + None, + None, +]; + +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("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("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"], + &["algorithm"], + &["algorithmic"], + &["algorithmically"], + &["algorithm", "algorithms"], + &["algorithmic"], + &["algorithmically"], + &["algorithm"], + &["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"], - &["algorithms"], - &["algorithms"], - &["algorithms"], - &["algorithms"], - &["algorithm"], - &["algorithm"], - &["algorithm"], - &["algorithm"], - &["algorithms"], - &["algorithms"], - &["algorithms"], - &["algorithm"], - &["algorithms"], - &["algorithm"], - &["algorithms"], + &["algorithmic"], + &["algorithmically"], &["algorithms"], &["algorithms"], ], - range: 4..=8, + 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("bric"), + dictgen::InsensitiveStr::Ascii("brra"), + dictgen::InsensitiveStr::Ascii("e"), + dictgen::InsensitiveStr::Ascii("rba"), + ], + values: &[ + &["algebraic"], + &["algebraic"], + &["algebra"], + &["algae"], + &["algebra"], + ], + range: 1..=7, }; static WORD_ALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89001,30 +170722,48 @@ static WORD_ALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], + &["alerts"], + &["alleviate"], + &["alleviates"], + &["alleviating"], + &["alert"], ], range: 2..=7, }; @@ -89048,6 +170787,7 @@ static WORD_ALC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -89064,6 +170804,7 @@ pub static WORD_ALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -89073,6 +170814,7 @@ pub static WORD_ALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["alchemist"], &["alchemy"], + &["alchemy"], &["alchemist"], &["alchemist"], &["alchemist"], @@ -89088,6 +170830,7 @@ pub static WORD_ALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["alcoholics"], &["alcoholism"], &["alcoholics"], + &["alcoholic"], &["alcoholics"], &["alcoholics"], &["alcoholics"], @@ -89103,9 +170846,23 @@ static WORD_ALB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_ALB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("iet")], - values: &[&["albeit"]], - range: 3..=3, + 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 { @@ -89115,11 +170872,60 @@ static WORD_AK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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: &[&["arkansas"], &["askreddit"]], - range: 6..=7, + values: &[ + &["ache"], + &["accumulate"], + &["accumulated"], + &["accumulates"], + &["accumulating"], + &["accumulation"], + &["accumulative"], + &["accumulator"], + &["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 { @@ -89128,9 +170934,45 @@ static WORD_AJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D }; pub static WORD_AJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("dectives")], - values: &[&["adjectives"]], - range: 8..=8, + 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"), + ], + values: &[ + &["adjacence"], + &["adjacencies"], + &["adjacency"], + &["adjacent"], + &["adjacency"], + &["adjacence"], + &["adjacencies"], + &["adjective"], + &["adjacencies"], + &["adjectives"], + &["adjacencies"], + &["adjournment"], + &["adjust"], + &["adjusted"], + &["adjustment"], + &["adjusting"], + &["adjustment"], + ], + range: 3..=8, }; static WORD_AI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89141,11 +170983,13 @@ static WORD_AI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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("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"), @@ -89153,7 +170997,10 @@ pub static WORD_AI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"), @@ -89165,14 +171012,18 @@ pub static WORD_AI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg 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"], &["alimony"], &["ancients"], &["airport"], + &["aerator"], &["airborne"], &["airborne"], &["airborne"], @@ -89181,6 +171032,9 @@ pub static WORD_AI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["aircraft"], &["aircraft"], &["airflow"], + &["aerial", "arial"], + &["airflow"], + &["heirloom"], &["airsoft"], &["airplane"], &["airplanes"], @@ -89192,8 +171046,10 @@ pub static WORD_AI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["airsoft"], &["arizona"], &["asian"], + &["axis"], + &["azimuth"], ], - range: 4..=8, + range: 2..=8, }; static WORD_AH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89203,7 +171059,10 @@ static WORD_AH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D pub static WORD_AH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("eared"), dictgen::InsensitiveStr::Ascii("ev"), + dictgen::InsensitiveStr::Ascii("lpa"), + dictgen::InsensitiveStr::Ascii("lpas"), dictgen::InsensitiveStr::Ascii("ppen"), dictgen::InsensitiveStr::Ascii("tiest"), dictgen::InsensitiveStr::Ascii("tletes"), @@ -89211,7 +171070,10 @@ pub static WORD_AH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("ve"), ], values: &[ + &["adhered"], &["have"], + &["alpha"], + &["alphas"], &["happen"], &["atheist"], &["athletes"], @@ -89261,9 +171123,13 @@ static WORD_AGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: }; pub static WORD_AGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("rement")], - values: &[&["argument"]], - range: 6..=6, + keys: &[ + dictgen::InsensitiveStr::Ascii("ment"), + dictgen::InsensitiveStr::Ascii("ments"), + dictgen::InsensitiveStr::Ascii("rement"), + ], + values: &[&["argument"], &["arguments"], &["argument"]], + range: 4..=6, }; static WORD_AGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89274,12 +171140,17 @@ static WORD_AGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("acultural"), + dictgen::InsensitiveStr::Ascii("ain"), 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("egates"), + dictgen::InsensitiveStr::Ascii("egation"), + dictgen::InsensitiveStr::Ascii("egator"), dictgen::InsensitiveStr::Ascii("eggate"), dictgen::InsensitiveStr::Ascii("eing"), dictgen::InsensitiveStr::Ascii("entina"), @@ -89287,10 +171158,15 @@ pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("essvie"), + dictgen::InsensitiveStr::Ascii("gument"), + dictgen::InsensitiveStr::Ascii("guments"), dictgen::InsensitiveStr::Ascii("icolture"), dictgen::InsensitiveStr::Ascii("iculteral"), dictgen::InsensitiveStr::Ascii("iculteur"), @@ -89308,6 +171184,7 @@ pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -89318,12 +171195,17 @@ pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["agricultural"], + &["again"], &["aggravate"], &["agreed"], &["agreement"], &["agreement"], + &["agreements"], + &["agreement"], &["aggregate"], &["aggregates"], + &["aggregation"], + &["aggregator"], &["aggregate"], &["agreeing"], &["argentina"], @@ -89331,10 +171213,15 @@ pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["aggression"], &["aggressive"], &["aggressively"], + &["aggressiveness"], + &["aggressivity"], &["aggressive"], &["aggressive"], &["aggressor"], &["aggressive"], + &["aggressive"], + &["argument"], + &["arguments"], &["agriculture"], &["agricultural"], &["agriculture"], @@ -89352,6 +171239,7 @@ pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["aggrieved"], &["agricultural"], &["agricultural"], + &["aggressive"], &["arguable"], &["arguably"], &["argument"], @@ -89372,8 +171260,9 @@ pub static WORD_AGO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict keys: &[ dictgen::InsensitiveStr::Ascii("nstic"), dictgen::InsensitiveStr::Ascii("nsticism"), + dictgen::InsensitiveStr::Ascii("rithm"), ], - values: &[&["agnostic"], &["agnosticism"]], + values: &[&["agnostic"], &["agnosticism"], &["algorithm"]], range: 5..=8, }; @@ -89445,7 +171334,7 @@ pub static WORD_AGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["again"], &["against"], &["again"], - &["again"], + &["again", "angina"], &["against"], &["agricultural"], ], @@ -89460,39 +171349,71 @@ static WORD_AGG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("essive"), + dictgen::InsensitiveStr::Ascii("essively"), + dictgen::InsensitiveStr::Ascii("gregate"), + dictgen::InsensitiveStr::Ascii("ragate"), dictgen::InsensitiveStr::Ascii("ragating"), + dictgen::InsensitiveStr::Ascii("ragator"), dictgen::InsensitiveStr::Ascii("ravanti"), dictgen::InsensitiveStr::Ascii("raveted"), + dictgen::InsensitiveStr::Ascii("reagate"), + dictgen::InsensitiveStr::Ascii("reataon"), + dictgen::InsensitiveStr::Ascii("reate"), + dictgen::InsensitiveStr::Ascii("reation"), dictgen::InsensitiveStr::Ascii("reed"), dictgen::InsensitiveStr::Ascii("reement"), + dictgen::InsensitiveStr::Ascii("regatet"), dictgen::InsensitiveStr::Ascii("regatore"), + dictgen::InsensitiveStr::Ascii("regetor"), + dictgen::InsensitiveStr::Ascii("reggate"), dictgen::InsensitiveStr::Ascii("regious"), 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("rovated"), dictgen::InsensitiveStr::Ascii("rovating"), ], values: &[ &["aggravates"], &["aggregate"], + &["aggregate"], + &["aggressive"], + &["aggressively"], + &["aggregate"], + &["aggregate"], &["aggravating"], + &["aggregator"], &["aggravating"], &["aggravated"], + &["aggregate"], + &["aggregation"], + &["aggregate"], + &["aggregation"], &["agreed"], &["agreement"], + &["aggregated"], + &["aggregate"], + &["aggregator"], &["aggregate"], &["egregious"], &["aggression"], &["aggressive"], &["aggressively"], &["aggressively"], + &["aggressively"], &["aggression"], &["aggression"], + &["aggravate"], + &["aggregate"], &["aggravated"], &["aggravating"], ], @@ -89508,108 +171429,291 @@ pub static WORD_AGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: 3..=5, + range: 2..=5, }; static WORD_AF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_AF_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_AF_CHILDREN), value: None, }; -pub static WORD_AF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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("air"), - dictgen::InsensitiveStr::Ascii("faires"), - dictgen::InsensitiveStr::Ascii("faris"), - dictgen::InsensitiveStr::Ascii("fectionatley"), - dictgen::InsensitiveStr::Ascii("fectionnate"), - dictgen::InsensitiveStr::Ascii("fiars"), - dictgen::InsensitiveStr::Ascii("ficianados"), - dictgen::InsensitiveStr::Ascii("ficionado"), - dictgen::InsensitiveStr::Ascii("ficionados"), - dictgen::InsensitiveStr::Ascii("filate"), - dictgen::InsensitiveStr::Ascii("filiato"), - dictgen::InsensitiveStr::Ascii("filiaton"), - dictgen::InsensitiveStr::Ascii("filiction"), - dictgen::InsensitiveStr::Ascii("filliate"), - dictgen::InsensitiveStr::Ascii("finitiy"), - dictgen::InsensitiveStr::Ascii("fintiy"), - dictgen::InsensitiveStr::Ascii("firmate"), - dictgen::InsensitiveStr::Ascii("firmitave"), - dictgen::InsensitiveStr::Ascii("firmitive"), - dictgen::InsensitiveStr::Ascii("firmitve"), - dictgen::InsensitiveStr::Ascii("fixiation"), - dictgen::InsensitiveStr::Ascii("flcition"), - dictgen::InsensitiveStr::Ascii("flection"), - dictgen::InsensitiveStr::Ascii("fleunt"), - dictgen::InsensitiveStr::Ascii("fliated"), - dictgen::InsensitiveStr::Ascii("fliation"), - dictgen::InsensitiveStr::Ascii("fliciton"), - dictgen::InsensitiveStr::Ascii("foradble"), - dictgen::InsensitiveStr::Ascii("fordible"), - dictgen::InsensitiveStr::Ascii("fort"), - dictgen::InsensitiveStr::Ascii("fortable"), - dictgen::InsensitiveStr::Ascii("frimative"), - dictgen::InsensitiveStr::Ascii("fulent"), - dictgen::InsensitiveStr::Ascii("gahnistan"), - dictgen::InsensitiveStr::Ascii("ganhistan"), - dictgen::InsensitiveStr::Ascii("ghanastan"), - dictgen::InsensitiveStr::Ascii("ghanisthan"), - dictgen::InsensitiveStr::Ascii("ghansitan"), - dictgen::InsensitiveStr::Ascii("hganistan"), - dictgen::InsensitiveStr::Ascii("ircan"), - dictgen::InsensitiveStr::Ascii("ircans"), - dictgen::InsensitiveStr::Ascii("orememtioned"), - dictgen::InsensitiveStr::Ascii("orementioend"), - dictgen::InsensitiveStr::Ascii("orementiond"), - dictgen::InsensitiveStr::Ascii("orementionned"), - dictgen::InsensitiveStr::Ascii("ricain"), - dictgen::InsensitiveStr::Ascii("ricanas"), - dictgen::InsensitiveStr::Ascii("ricaners"), - dictgen::InsensitiveStr::Ascii("ricaness"), - dictgen::InsensitiveStr::Ascii("ricanos"), - dictgen::InsensitiveStr::Ascii("ricas"), - dictgen::InsensitiveStr::Ascii("terhtought"), - dictgen::InsensitiveStr::Ascii("termaket"), - dictgen::InsensitiveStr::Ascii("ternarket"), - dictgen::InsensitiveStr::Ascii("ternon"), - dictgen::InsensitiveStr::Ascii("ternooon"), - dictgen::InsensitiveStr::Ascii("terthougt"), - dictgen::InsensitiveStr::Ascii("terthougth"), - dictgen::InsensitiveStr::Ascii("wully"), + 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("rer"), + dictgen::InsensitiveStr::Ascii("zer"), ], values: &[ - &["affair"], + &["afterthought"], + &["aftermarket"], + &["aftermarket"], + &["afternoon"], + &["afternoon"], + &["afterthought"], + &["afterthought"], + &["after"], + &["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("icain"), + dictgen::InsensitiveStr::Ascii("icanas"), + dictgen::InsensitiveStr::Ascii("icaners"), + dictgen::InsensitiveStr::Ascii("icaness"), + dictgen::InsensitiveStr::Ascii("icanos"), + dictgen::InsensitiveStr::Ascii("icas"), + ], + values: &[ + &["african"], + &["africans"], + &["africans"], + &["africans"], + &["africans"], + &["africans"], + ], + range: 4..=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("ectionatley"), + dictgen::InsensitiveStr::Ascii("ectionnate"), + dictgen::InsensitiveStr::Ascii("ekt"), + dictgen::InsensitiveStr::Ascii("iars"), + dictgen::InsensitiveStr::Ascii("icianados"), + dictgen::InsensitiveStr::Ascii("icionado"), + dictgen::InsensitiveStr::Ascii("icionados"), + dictgen::InsensitiveStr::Ascii("ilate"), + dictgen::InsensitiveStr::Ascii("ilates"), + 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("intiy"), + dictgen::InsensitiveStr::Ascii("intize"), + 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("ort"), + dictgen::InsensitiveStr::Ascii("ortable"), + dictgen::InsensitiveStr::Ascii("orts"), + dictgen::InsensitiveStr::Ascii("raid"), + dictgen::InsensitiveStr::Ascii("rimative"), + dictgen::InsensitiveStr::Ascii("ulent"), + ], + values: &[ + &["affect", "effect"], &["affairs"], &["affairs"], &["affectionate"], &["affectionate"], + &["affect", "effect"], &["affairs"], &["aficionados"], &["aficionado"], &["aficionados"], &["affiliate"], + &["affiliates"], &["affiliation"], &["affiliation"], &["affiliation"], &["affiliate"], + &["affinities"], &["affinity"], + &["affinities", "affinity"], + &["affinitize"], &["affinity"], + &["affinitize"], &["affirmative"], &["affirmative"], &["affirmative"], &["affirmative"], + &["affinity"], &["affiliation"], &["affliction"], &["affliction"], @@ -89619,38 +171723,49 @@ pub static WORD_AF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["affliction"], &["affordable"], &["affordable"], - &["afford"], + &["afford", "effort"], &["affordable"], + &["affords"], + &["afraid"], &["affirmative"], &["affluent"], - &["afghanistan"], - &["afghanistan"], - &["afghanistan"], - &["afghanistan"], - &["afghanistan"], - &["afghanistan"], - &["african"], - &["africans"], - &["aforementioned"], - &["aforementioned"], - &["aforementioned"], - &["aforementioned"], - &["african"], - &["africans"], - &["africans"], - &["africans"], - &["africans"], - &["africans"], - &["afterthought"], - &["aftermarket"], - &["aftermarket"], - &["afternoon"], - &["afternoon"], - &["afterthought"], - &["afterthought"], - &["awfully"], ], - range: 3..=13, + range: 3..=11, +}; + +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("tr"), + ], + values: &[ + &["affect", "effect"], + &["affecting"], + &["after"], + &["after"], + ], + range: 1..=5, +}; + +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 { @@ -89660,12 +171775,16 @@ static WORD_AE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::D 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"), @@ -89676,16 +171795,21 @@ pub static WORD_AE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg dictgen::InsensitiveStr::Ascii("stheticaly"), dictgen::InsensitiveStr::Ascii("stheticlly"), dictgen::InsensitiveStr::Ascii("sthitically"), + dictgen::InsensitiveStr::Ascii("sy"), dictgen::InsensitiveStr::Ascii("thistic"), dictgen::InsensitiveStr::Ascii("thists"), ], values: &[ + &["deactivate", "activate"], &["aerospace"], + &["equidistant"], + &["equivalent"], &["aerial"], &["aerials"], &["aerospace"], &["aerospace"], &["aerospace"], + &["easily"], &["aesthetic"], &["aesthetically"], &["aesthetics"], @@ -89696,10 +171820,11 @@ pub static WORD_AE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictg &["aesthetically"], &["aesthetically"], &["aesthetically"], + &["easy"], &["atheistic"], &["atheists"], ], - range: 4..=11, + range: 2..=11, }; static WORD_AD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89714,7 +171839,7 @@ static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_ADD_NODE), Some(&WORD_ADE_NODE), None, - None, + Some(&WORD_ADG_NODE), Some(&WORD_ADH_NODE), Some(&WORD_ADI_NODE), Some(&WORD_ADJ_NODE), @@ -89730,82 +171855,166 @@ static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, 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_ADV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ADV_CHILDREN), +static WORD_ADVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ADVS_CHILDREN), value: None, }; -pub static WORD_ADV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ADVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("antadges"), - dictgen::InsensitiveStr::Ascii("antageos"), - dictgen::InsensitiveStr::Ascii("antageus"), - dictgen::InsensitiveStr::Ascii("antagious"), - dictgen::InsensitiveStr::Ascii("antagous"), - dictgen::InsensitiveStr::Ascii("antegeous"), - dictgen::InsensitiveStr::Ascii("anteges"), - dictgen::InsensitiveStr::Ascii("atange"), - dictgen::InsensitiveStr::Ascii("atanges"), - dictgen::InsensitiveStr::Ascii("entageous"), - dictgen::InsensitiveStr::Ascii("enterous"), - dictgen::InsensitiveStr::Ascii("entourus"), - dictgen::InsensitiveStr::Ascii("entrous"), - dictgen::InsensitiveStr::Ascii("entrues"), - dictgen::InsensitiveStr::Ascii("entue"), - dictgen::InsensitiveStr::Ascii("entuers"), - dictgen::InsensitiveStr::Ascii("entuous"), - dictgen::InsensitiveStr::Ascii("entureous"), - dictgen::InsensitiveStr::Ascii("entureres"), - dictgen::InsensitiveStr::Ascii("enturious"), - dictgen::InsensitiveStr::Ascii("enturos"), - dictgen::InsensitiveStr::Ascii("enturs"), - dictgen::InsensitiveStr::Ascii("enturuous"), - dictgen::InsensitiveStr::Ascii("enturus"), - dictgen::InsensitiveStr::Ascii("entus"), - dictgen::InsensitiveStr::Ascii("eristy"), - dictgen::InsensitiveStr::Ascii("ersiting"), - dictgen::InsensitiveStr::Ascii("erst"), - dictgen::InsensitiveStr::Ascii("erticed"), - dictgen::InsensitiveStr::Ascii("erticement"), - dictgen::InsensitiveStr::Ascii("ertis"), - dictgen::InsensitiveStr::Ascii("ertisiers"), - dictgen::InsensitiveStr::Ascii("ertisiment"), - dictgen::InsensitiveStr::Ascii("ertisment"), - dictgen::InsensitiveStr::Ascii("ertisments"), - dictgen::InsensitiveStr::Ascii("ertisors"), - dictgen::InsensitiveStr::Ascii("ertisted"), - dictgen::InsensitiveStr::Ascii("ertisters"), - dictgen::InsensitiveStr::Ascii("ertisting"), - dictgen::InsensitiveStr::Ascii("ertisy"), - dictgen::InsensitiveStr::Ascii("esary"), - dictgen::InsensitiveStr::Ascii("iced"), - dictgen::InsensitiveStr::Ascii("irtisement"), - dictgen::InsensitiveStr::Ascii("iseer"), - dictgen::InsensitiveStr::Ascii("iseur"), - dictgen::InsensitiveStr::Ascii("isorys"), - dictgen::InsensitiveStr::Ascii("ocade"), - dictgen::InsensitiveStr::Ascii("ocats"), - dictgen::InsensitiveStr::Ascii("ocay"), - dictgen::InsensitiveStr::Ascii("sior"), - dictgen::InsensitiveStr::Ascii("siors"), + 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("ced"), + 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: &[ + &["advised"], + &["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("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: &[ - &["advantages"], - &["advantageous"], - &["advantageous"], - &["advantageous"], - &["advantageous"], &["advantageous"], &["advantages"], - &["advantage"], - &["advantages"], - &["advantageous"], &["adventures"], &["adventurous"], &["adventurous"], @@ -89821,9 +172030,11 @@ pub static WORD_ADV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["adventurous"], &["adventurous"], &["adventures"], + &["advertised"], &["adversity"], &["advertising"], &["adverts"], + &["advertise"], &["advertised"], &["advertisement"], &["adverts"], @@ -89835,20 +172046,58 @@ pub static WORD_ADV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["advertised"], &["advertisers"], &["advertising"], + &["advertisement"], + &["advertisements"], &["adversity"], &["adversary"], - &["advised"], - &["advertisement"], - &["adviser"], - &["adviser"], - &["advisors"], - &["advocated"], - &["advocates"], - &["advocacy"], - &["advisor"], - &["advisors"], + &["advertise"], ], - range: 4..=10, + 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 { @@ -89861,8 +172110,16 @@ pub static WORD_ADU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], ], - values: &[&["audiobook"], &["adultery"], &["adultery"]], range: 4..=6, }; @@ -89873,6 +172130,7 @@ static WORD_ADR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -89882,11 +172140,18 @@ pub static WORD_ADR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -89896,9 +172161,15 @@ pub static WORD_ADR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["addressing"], &["address"], &["addressable"], + &["address"], &["addressed"], + &["addresses"], &["addressing"], + &["address"], + &["addresses"], &["adorable"], + &["address"], + &["addresses"], ], range: 2..=7, }; @@ -89926,12 +172197,20 @@ static WORD_ADP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ADP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("apted"), dictgen::InsensitiveStr::Ascii("atation"), dictgen::InsensitiveStr::Ascii("ater"), dictgen::InsensitiveStr::Ascii("aters"), + dictgen::InsensitiveStr::Ascii("ter"), ], - values: &[&["adaptation"], &["adapter"], &["adapters"]], - range: 4..=7, + values: &[ + &["adapted"], + &["adaptation"], + &["adapter"], + &["adapters"], + &["adapter"], + ], + range: 3..=7, }; static WORD_ADO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89941,6 +172220,7 @@ static WORD_ADO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -89951,12 +172231,15 @@ pub static WORD_ADO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -89967,12 +172250,14 @@ pub static WORD_ADO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["adolescence"], &["adolescent"], &["adolescent"], + &["adopter", "adaptor"], + &["adopters", "adaptors"], &["adorable"], &["advocacy"], &["advocated"], &["advocates"], ], - range: 5..=8, + range: 4..=8, }; static WORD_ADN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -89994,17 +172279,23 @@ static WORD_ADM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ADM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("endment"), + dictgen::InsensitiveStr::Ascii("i"), dictgen::InsensitiveStr::Ascii("inastrator"), dictgen::InsensitiveStr::Ascii("ininistrative"), + dictgen::InsensitiveStr::Ascii("ininistrator"), + dictgen::InsensitiveStr::Ascii("ininistrators"), + dictgen::InsensitiveStr::Ascii("ininstrator"), dictgen::InsensitiveStr::Ascii("inistartion"), dictgen::InsensitiveStr::Ascii("inistartor"), dictgen::InsensitiveStr::Ascii("inistartors"), + dictgen::InsensitiveStr::Ascii("inistation"), dictgen::InsensitiveStr::Ascii("inisted"), dictgen::InsensitiveStr::Ascii("inisterd"), dictgen::InsensitiveStr::Ascii("inistor"), dictgen::InsensitiveStr::Ascii("inistored"), dictgen::InsensitiveStr::Ascii("inistr"), dictgen::InsensitiveStr::Ascii("inistraion"), + dictgen::InsensitiveStr::Ascii("inistraively"), dictgen::InsensitiveStr::Ascii("inistrar"), dictgen::InsensitiveStr::Ascii("inistraron"), dictgen::InsensitiveStr::Ascii("inistrater"), @@ -90030,11 +172321,13 @@ pub static WORD_ADM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("insitrative"), dictgen::InsensitiveStr::Ascii("insitrator"), dictgen::InsensitiveStr::Ascii("insitrators"), + dictgen::InsensitiveStr::Ascii("inssion"), dictgen::InsensitiveStr::Ascii("instered"), dictgen::InsensitiveStr::Ascii("instrate"), dictgen::InsensitiveStr::Ascii("instration"), dictgen::InsensitiveStr::Ascii("instrative"), dictgen::InsensitiveStr::Ascii("instrator"), + dictgen::InsensitiveStr::Ascii("instrators"), dictgen::InsensitiveStr::Ascii("iraal"), dictgen::InsensitiveStr::Ascii("issability"), dictgen::InsensitiveStr::Ascii("issable"), @@ -90044,21 +172337,29 @@ pub static WORD_ADM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ittadly"), dictgen::InsensitiveStr::Ascii("ittetly"), dictgen::InsensitiveStr::Ascii("ittidly"), + dictgen::InsensitiveStr::Ascii("n"), + dictgen::InsensitiveStr::Ascii("nistrator"), dictgen::InsensitiveStr::Ascii("rial"), ], values: &[ &["amendment"], + &["admin"], &["administrator"], &["administrative"], + &["administrator"], + &["administrators"], + &["administrator"], &["administration"], &["administrator"], &["administrators"], + &["administration"], &["administered"], &["administered"], - &["administer"], + &["administer", "administrator"], &["administer"], &["administer"], &["administration"], + &["administratively"], &["administrator"], &["administrator"], &["administrator"], @@ -90084,11 +172385,13 @@ pub static WORD_ADM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["administrative"], &["administrator"], &["administrators"], + &["admission"], &["administered"], &["administrate"], &["administration"], &["administrative"], &["administrator"], + &["administrators"], &["admiral"], &["admissibility"], &["admissible"], @@ -90098,9 +172401,11 @@ pub static WORD_ADM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["admittedly"], &["admittedly"], &["admittedly"], + &["admin"], + &["administrator"], &["admiral"], ], - range: 4..=13, + range: 1..=13, }; static WORD_ADK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90124,20 +172429,72 @@ static WORD_ADJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ADJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("acentcy"), + dictgen::InsensitiveStr::Ascii("acentsy"), + dictgen::InsensitiveStr::Ascii("actend"), + dictgen::InsensitiveStr::Ascii("ancent"), + dictgen::InsensitiveStr::Ascii("ascent"), + dictgen::InsensitiveStr::Ascii("asence"), + dictgen::InsensitiveStr::Ascii("asencies"), + dictgen::InsensitiveStr::Ascii("asensy"), + dictgen::InsensitiveStr::Ascii("asent"), + dictgen::InsensitiveStr::Ascii("ast"), + dictgen::InsensitiveStr::Ascii("cence"), + dictgen::InsensitiveStr::Ascii("cencies"), + dictgen::InsensitiveStr::Ascii("cent"), + dictgen::InsensitiveStr::Ascii("centcy"), dictgen::InsensitiveStr::Ascii("ectiveus"), dictgen::InsensitiveStr::Ascii("ectivos"), dictgen::InsensitiveStr::Ascii("ectivs"), + 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("ustible"), + dictgen::InsensitiveStr::Ascii("ustificat"), + dictgen::InsensitiveStr::Ascii("ustification"), + dictgen::InsensitiveStr::Ascii("ustmant"), + dictgen::InsensitiveStr::Ascii("ustmants"), + dictgen::InsensitiveStr::Ascii("ustmenet"), ], values: &[ + &["adjacency", "adjacence"], + &["adjacency"], + &["adjacent"], + &["adjacent"], + &["adjacent"], + &["adjacence"], + &["adjacencies"], + &["adjacency"], + &["adjacent"], + &["adjust"], + &["adjacence"], + &["adjacencies"], + &["adjacent"], + &["adjacency"], &["adjectives"], &["adjectives"], &["adjectives"], + &["adjacence"], + &["adjacencies"], + &["adjusted"], + &["adjacent"], + &["adjustment"], &["adjustable"], + &["adjustment"], + &["adjustments"], &["adjustable"], + &["justification"], + &["justification"], + &["adjustment"], + &["adjustments"], + &["adjustment"], ], - range: 6..=8, + range: 3..=12, }; static WORD_ADI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90147,12 +172504,42 @@ static WORD_ADI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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: &[&["adviser"], &["advisor"], &["advisors"]], - range: 4..=5, + values: &[ + &["adjacent"], + &["addition"], + &["admin"], + &["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 { @@ -90171,6 +172558,20 @@ pub static WORD_ADH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 5..=6, }; +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_ADE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ADE_CHILDREN), value: None, @@ -90211,68 +172612,320 @@ pub static WORD_ADE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict }; static WORD_ADD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ADD_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ADD_CHILDREN), value: None, }; -pub static WORD_ADD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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("cits"), - dictgen::InsensitiveStr::Ascii("erss"), - dictgen::InsensitiveStr::Ascii("icitons"), - dictgen::InsensitiveStr::Ascii("ictes"), - dictgen::InsensitiveStr::Ascii("ictin"), - dictgen::InsensitiveStr::Ascii("ictis"), + dictgen::InsensitiveStr::Ascii("ed"), + dictgen::InsensitiveStr::Ascii("ion"), dictgen::InsensitiveStr::Ascii("ional"), dictgen::InsensitiveStr::Ascii("ionally"), - dictgen::InsensitiveStr::Ascii("itinally"), - dictgen::InsensitiveStr::Ascii("itionaly"), - dictgen::InsensitiveStr::Ascii("itivies"), - dictgen::InsensitiveStr::Ascii("itivley"), - dictgen::InsensitiveStr::Ascii("itonal"), - dictgen::InsensitiveStr::Ascii("itonally"), - dictgen::InsensitiveStr::Ascii("ittions"), - dictgen::InsensitiveStr::Ascii("mission"), - dictgen::InsensitiveStr::Ascii("opt"), - dictgen::InsensitiveStr::Ascii("opted"), - dictgen::InsensitiveStr::Ascii("optive"), - dictgen::InsensitiveStr::Ascii("res"), - dictgen::InsensitiveStr::Ascii("resable"), - dictgen::InsensitiveStr::Ascii("resed"), - dictgen::InsensitiveStr::Ascii("resing"), - dictgen::InsensitiveStr::Ascii("ressess"), - dictgen::InsensitiveStr::Ascii("tion"), - dictgen::InsensitiveStr::Ascii("tional"), + 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("es"), + dictgen::InsensitiveStr::Ascii("esable"), + dictgen::InsensitiveStr::Ascii("esed"), + dictgen::InsensitiveStr::Ascii("eses"), + dictgen::InsensitiveStr::Ascii("esess"), + dictgen::InsensitiveStr::Ascii("esing"), + dictgen::InsensitiveStr::Ascii("esse"), + dictgen::InsensitiveStr::Ascii("essess"), + dictgen::InsensitiveStr::Ascii("essings"), + dictgen::InsensitiveStr::Ascii("esss"), + dictgen::InsensitiveStr::Ascii("esssed"), + dictgen::InsensitiveStr::Ascii("essses"), + dictgen::InsensitiveStr::Ascii("esssing"), + dictgen::InsensitiveStr::Ascii("ress"), ], values: &[ - &["addicts"], &["address"], - &["addictions"], - &["addicts"], - &["addictions"], - &["addictions"], - &["additional"], - &["additionally"], - &["additionally"], - &["additionally"], - &["additive"], - &["additive"], - &["additional"], - &["additionally"], - &["addictions"], - &["admission"], - &["adopt"], - &["adopted"], - &["adoptive"], + &["address"], + &["address"], &["address"], &["addressable"], &["addressed"], - &["addressing"], &["addresses"], + &["addresses"], + &["addressing"], + &["addresses", "address"], + &["addresses"], + &["addressing"], + &["address"], + &["addressed"], + &["addresses"], + &["addressing"], + &["address"], + ], + range: 2..=7, +}; + +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("pt"), + dictgen::InsensitiveStr::Ascii("pted"), + dictgen::InsensitiveStr::Ascii("ptive"), + ], + values: &[&["adopt"], &["adopted"], &["adoptive", "adaptive"]], + range: 2..=5, +}; + +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("onal"), + dictgen::InsensitiveStr::Ascii("onally"), + dictgen::InsensitiveStr::Ascii("tianally"), + dictgen::InsensitiveStr::Ascii("tinally"), + dictgen::InsensitiveStr::Ascii("tioanlly"), + dictgen::InsensitiveStr::Ascii("tiona"), + dictgen::InsensitiveStr::Ascii("tionallly"), + 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("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"], + &["additionally"], + &["additionally"], + &["additionally"], + &["additionally"], + &["additional"], + &["additionally"], + &["additionally"], + &["additionally"], + &["additional"], + &["additionally"], + &["additionally"], + &["additive"], + &["additive"], &["addition"], &["additional"], + &["additionally"], + &["additionally"], + &["addictions"], ], - range: 3..=8, + 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"], + &["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("ress"), + dictgen::InsensitiveStr::Ascii("resses"), + dictgen::InsensitiveStr::Ascii("s"), + ], + values: &[ + &["added"], + &["adding"], + &["address"], + &["addresses"], + &["adds"], + ], + range: 1..=6, +}; + +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 { @@ -90298,24 +172951,56 @@ static WORD_ADA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ADA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("pated"), + dictgen::InsensitiveStr::Ascii("pater"), + dictgen::InsensitiveStr::Ascii("paters"), + 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("tper"), + dictgen::InsensitiveStr::Ascii("tpers"), + dictgen::InsensitiveStr::Ascii("vance"), dictgen::InsensitiveStr::Ascii("vanced"), ], values: &[ + &["adapted"], + &["adapter"], + &["adapters"], + &["adapt", "adapted", "adopt", "adopted"], + &["adaptive"], + &["adapted", "adapt", "adopted", "adopt"], + &["adaptive"], + &["adaptation"], &["adaptation"], &["adapter"], &["adaptation"], + &["adapter"], + &["adapted"], &["adapters"], + &["adaptive"], + &["adaptive", "adoptive"], + &["adequate"], + &["adequately"], &["adequately"], &["adapter"], + &["adapters"], + &["advance"], &["advanced"], ], - range: 4..=7, + range: 2..=7, }; static WORD_AC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90327,7 +173012,7 @@ static WORD_AC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> Some(&WORD_ACA_NODE), None, Some(&WORD_ACC_NODE), - None, + Some(&WORD_ACD_NODE), Some(&WORD_ACE_NODE), Some(&WORD_ACF_NODE), None, @@ -90370,121 +173055,304 @@ static WORD_ACU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], + &["accumulate"], + &["accumulated"], + &["accumulates"], + &["accumulating"], + &["accumulation"], + &["accumulative"], + &["accumulator"], + &["acquire"], &["accuracy"], + &["accurate"], &["causation"], &["accused"], &["causing"], &["accustom"], &["accustomed"], + &["actual"], &["actuality"], &["actually"], &["actually"], &["auctions"], + &["actual"], ], - range: 3..=7, + range: 2..=8, }; static WORD_ACT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ACT_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ACT_CHILDREN), value: None, }; -pub static WORD_ACT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +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), + None, + 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_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("aully"), - dictgen::InsensitiveStr::Ascii("auly"), - dictgen::InsensitiveStr::Ascii("icating"), - dictgen::InsensitiveStr::Ascii("ication"), - dictgen::InsensitiveStr::Ascii("ivacion"), - dictgen::InsensitiveStr::Ascii("ivaste"), - dictgen::InsensitiveStr::Ascii("ivateing"), - dictgen::InsensitiveStr::Ascii("ivaters"), - dictgen::InsensitiveStr::Ascii("ivatin"), - dictgen::InsensitiveStr::Ascii("ivationg"), - dictgen::InsensitiveStr::Ascii("ivelly"), - dictgen::InsensitiveStr::Ascii("iviates"), - dictgen::InsensitiveStr::Ascii("iviites"), - dictgen::InsensitiveStr::Ascii("ivisim"), - dictgen::InsensitiveStr::Ascii("ivisiom"), - dictgen::InsensitiveStr::Ascii("ivisit"), - dictgen::InsensitiveStr::Ascii("ivisits"), - dictgen::InsensitiveStr::Ascii("ivistas"), - dictgen::InsensitiveStr::Ascii("ivistes"), - dictgen::InsensitiveStr::Ascii("ivistion"), - dictgen::InsensitiveStr::Ascii("ivit"), - dictgen::InsensitiveStr::Ascii("ivite"), - dictgen::InsensitiveStr::Ascii("ivites"), - dictgen::InsensitiveStr::Ascii("iviting"), - dictgen::InsensitiveStr::Ascii("ivits"), - dictgen::InsensitiveStr::Ascii("ivizion"), - dictgen::InsensitiveStr::Ascii("ivley"), - dictgen::InsensitiveStr::Ascii("ivly"), - dictgen::InsensitiveStr::Ascii("resess"), - dictgen::InsensitiveStr::Ascii("resss"), - dictgen::InsensitiveStr::Ascii("ualey"), - dictgen::InsensitiveStr::Ascii("ualiy"), - dictgen::InsensitiveStr::Ascii("ualky"), - dictgen::InsensitiveStr::Ascii("ualmy"), - dictgen::InsensitiveStr::Ascii("ualoy"), - dictgen::InsensitiveStr::Ascii("ualpy"), - dictgen::InsensitiveStr::Ascii("ualty"), - dictgen::InsensitiveStr::Ascii("ualy"), - dictgen::InsensitiveStr::Ascii("ulay"), + 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("rally"), + dictgen::InsensitiveStr::Ascii("sally"), ], values: &[ + &["actual"], &["actually"], + &["actual"], &["actually"], - &["activating"], - &["activation"], - &["activation"], - &["activates"], - &["activating"], - &["activates"], - &["activation"], - &["activating"], - &["actively"], - &["activist"], - &["activist"], - &["activism"], - &["activism"], - &["activist"], - &["activist"], - &["activists"], - &["activists"], - &["activision"], - &["activist"], - &["activities"], - &["activities"], - &["activating"], - &["activities"], - &["activision"], - &["actively"], - &["actively"], - &["actresses"], - &["actresses"], &["actually"], &["actuality"], &["actually"], + &["actually", "actual"], &["actually"], &["actually"], &["actually"], &["actually"], &["actually"], &["actually"], + &["actually"], + &["actual"], + &["action"], + &["actionable"], + &["actual"], + &["actually"], + &["actually"], + &["actually"], + &["actually"], + &["actually"], ], - range: 4..=8, + 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::Flat(&WORD_ACTI_CHILDREN), + value: None, +}; + +pub static WORD_ACTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { + keys: &[ + dictgen::InsensitiveStr::Ascii("al"), + dictgen::InsensitiveStr::Ascii("bity"), + dictgen::InsensitiveStr::Ascii("cating"), + dictgen::InsensitiveStr::Ascii("cation"), + dictgen::InsensitiveStr::Ascii("ne"), + dictgen::InsensitiveStr::Ascii("ual"), + dictgen::InsensitiveStr::Ascii("v"), + dictgen::InsensitiveStr::Ascii("vacion"), + dictgen::InsensitiveStr::Ascii("vaed"), + dictgen::InsensitiveStr::Ascii("vaste"), + dictgen::InsensitiveStr::Ascii("vateing"), + dictgen::InsensitiveStr::Ascii("vaters"), + dictgen::InsensitiveStr::Ascii("vatin"), + dictgen::InsensitiveStr::Ascii("vationg"), + dictgen::InsensitiveStr::Ascii("ved"), + dictgen::InsensitiveStr::Ascii("velly"), + dictgen::InsensitiveStr::Ascii("veta"), + dictgen::InsensitiveStr::Ascii("vete"), + dictgen::InsensitiveStr::Ascii("viates"), + dictgen::InsensitiveStr::Ascii("viites"), + dictgen::InsensitiveStr::Ascii("visim"), + dictgen::InsensitiveStr::Ascii("visiom"), + dictgen::InsensitiveStr::Ascii("visit"), + dictgen::InsensitiveStr::Ascii("visits"), + dictgen::InsensitiveStr::Ascii("vistas"), + dictgen::InsensitiveStr::Ascii("vistes"), + dictgen::InsensitiveStr::Ascii("vistion"), + dictgen::InsensitiveStr::Ascii("vit"), + dictgen::InsensitiveStr::Ascii("vite"), + dictgen::InsensitiveStr::Ascii("vites"), + dictgen::InsensitiveStr::Ascii("viti"), + dictgen::InsensitiveStr::Ascii("viting"), + dictgen::InsensitiveStr::Ascii("vitis"), + dictgen::InsensitiveStr::Ascii("vitiy"), + dictgen::InsensitiveStr::Ascii("vits"), + dictgen::InsensitiveStr::Ascii("vizion"), + dictgen::InsensitiveStr::Ascii("vley"), + dictgen::InsensitiveStr::Ascii("vly"), + dictgen::InsensitiveStr::Ascii("vtes"), + dictgen::InsensitiveStr::Ascii("vties"), + dictgen::InsensitiveStr::Ascii("vty"), + dictgen::InsensitiveStr::Ascii("vw"), + ], + values: &[ + &["actual"], + &["activity"], + &["activating"], + &["activation"], + &["active"], + &["actual"], + &["active"], + &["activation"], + &["activated"], + &["activates"], + &["activating"], + &["activates"], + &["activation"], + &["activating"], + &["activated"], + &["actively"], + &["activate"], + &["activate"], + &["activist"], + &["activist"], + &["activism"], + &["activism"], + &["activist"], + &["activist"], + &["activists"], + &["activists"], + &["activision"], + &["activist"], + &["activities"], + &["activities"], + &["activity", "activities"], + &["activating"], + &["activities"], + &["activity"], + &["activities"], + &["activision"], + &["actively"], + &["actively"], + &["activates"], + &["activities"], + &["activity"], + &["active"], + ], + range: 1..=7, +}; + +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("lly"), + dictgen::InsensitiveStr::Ascii("ul"), + dictgen::InsensitiveStr::Ascii("ully"), + dictgen::InsensitiveStr::Ascii("uly"), + ], + values: &[&["actually"], &["actual"], &["actually"], &["actually"]], + range: 2..=4, }; static WORD_ACS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90497,9 +173365,17 @@ pub static WORD_ACS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("ended"), dictgen::InsensitiveStr::Ascii("ending"), dictgen::InsensitiveStr::Ascii("ension"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("sumed"), ], - values: &[&["ascended"], &["ascending"], &["ascension"]], - range: 5..=6, + values: &[ + &["ascended"], + &["ascending"], + &["ascension"], + &["cases", "access"], + &["assumed"], + ], + range: 2..=6, }; static WORD_ACR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90509,24 +173385,28 @@ static WORD_ACR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("oynms"), + dictgen::InsensitiveStr::Ascii("ued"), dictgen::InsensitiveStr::Ascii("ynoms"), ], values: &[ + &["acreage"], &["acrylic"], &["acronyms"], &["acronyms"], &["acronyms"], &["acronyms"], &["acronyms"], + &["accrued"], &["acronyms"], ], - range: 4..=6, + range: 3..=6, }; static WORD_ACQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90554,13 +173434,19 @@ pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("uianted"), dictgen::InsensitiveStr::Ascii("uiantence"), dictgen::InsensitiveStr::Ascii("uiantences"), + dictgen::InsensitiveStr::Ascii("uiesence"), dictgen::InsensitiveStr::Ascii("uifer"), dictgen::InsensitiveStr::Ascii("uinated"), dictgen::InsensitiveStr::Ascii("uisation"), dictgen::InsensitiveStr::Ascii("uisito"), dictgen::InsensitiveStr::Ascii("uisiton"), dictgen::InsensitiveStr::Ascii("uited"), + dictgen::InsensitiveStr::Ascii("ure"), + dictgen::InsensitiveStr::Ascii("ured"), + dictgen::InsensitiveStr::Ascii("ures"), dictgen::InsensitiveStr::Ascii("uried"), + dictgen::InsensitiveStr::Ascii("uries"), + dictgen::InsensitiveStr::Ascii("uring"), ], values: &[ &["acquainted"], @@ -90581,15 +173467,21 @@ pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["acquainted"], &["acquaintance"], &["acquaintances"], + &["acquiescence"], &["acquire"], &["acquainted"], &["acquisition"], &["acquisition"], &["acquisition"], &["acquitted"], + &["acquire"], &["acquired"], + &["acquires"], + &["acquired"], + &["acquires", "equerries"], + &["acquiring"], ], - range: 5..=10, + range: 3..=10, }; static WORD_ACO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90599,47 +173491,84 @@ static WORD_ACO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("palypse"), dictgen::InsensitiveStr::Ascii("palyptic"), dictgen::InsensitiveStr::Ascii("rding"), dictgen::InsensitiveStr::Ascii("rdingly"), + dictgen::InsensitiveStr::Ascii("rdinng"), 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"], &["apocalypse"], &["apocalyptic"], &["according"], &["accordingly"], + &["according"], &["acronyms"], + &["across"], + &["according"], + &["account"], + &["accounts"], &["acoustic"], &["acoustic"], &["avocados"], ], - range: 5..=11, + range: 3..=11, }; static WORD_ACN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ACN_CHILDREN), - value: None, + value: Some(&["can", "acne"]), }; pub static WORD_ACN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("edote")], - values: &[&["anecdote"]], - range: 5..=5, + 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 { @@ -90660,6 +173589,12 @@ static WORD_ACK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: pub static WORD_ACK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ + dictgen::InsensitiveStr::Ascii("nodledgment"), + dictgen::InsensitiveStr::Ascii("noledge"), + dictgen::InsensitiveStr::Ascii("noledged"), + dictgen::InsensitiveStr::Ascii("noledges"), + dictgen::InsensitiveStr::Ascii("noledging"), + dictgen::InsensitiveStr::Ascii("noledgment"), dictgen::InsensitiveStr::Ascii("nolwedge"), dictgen::InsensitiveStr::Ascii("nolwedged"), dictgen::InsensitiveStr::Ascii("nolwedgement"), @@ -90688,11 +173623,23 @@ pub static WORD_ACK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nowlege"), dictgen::InsensitiveStr::Ascii("nowleged"), dictgen::InsensitiveStr::Ascii("nowleges"), + dictgen::InsensitiveStr::Ascii("nowleging"), dictgen::InsensitiveStr::Ascii("nwoledge"), + dictgen::InsensitiveStr::Ascii("owledge"), + dictgen::InsensitiveStr::Ascii("owledged"), + dictgen::InsensitiveStr::Ascii("owledgement"), + dictgen::InsensitiveStr::Ascii("owledges"), + dictgen::InsensitiveStr::Ascii("owledging"), dictgen::InsensitiveStr::Ascii("umulation"), dictgen::InsensitiveStr::Ascii("ward"), ], values: &[ + &["acknowledgment"], + &["acknowledge"], + &["acknowledged"], + &["acknowledges"], + &["acknowledging"], + &["acknowledgment"], &["acknowledge"], &["acknowledged"], &["acknowledgement"], @@ -90719,34 +173666,62 @@ pub static WORD_ACK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["acknowledges"], &["acknowledging"], &["acknowledge"], + &["acknowledge", "acknowledged"], + &["acknowledges"], + &["acknowledging"], + &["acknowledges"], &["acknowledge"], + &["acknowledged"], + &["acknowledgement"], &["acknowledges"], - &["acknowledges"], + &["acknowledging"], &["accumulation"], - &["awkward"], + &["awkward", "backward"], ], range: 4..=12, }; static WORD_ACI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { children: dictgen::DictTrieChild::Flat(&WORD_ACI_CHILDREN), - value: None, + value: Some(&["acpi"]), }; pub static WORD_ACI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ dictgen::InsensitiveStr::Ascii("dent"), + dictgen::InsensitiveStr::Ascii("ent"), + 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"], + &["ancient"], + &["ascii"], + &["action"], + &["actions"], + &["activate"], + &["activation"], + &["activity"], + &["activate"], &["activates"], &["activating"], + &["active"], &["activision"], + &["activate"], + &["active"], ], - range: 4..=7, + range: 1..=8, }; static WORD_ACH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90781,12 +173756,22 @@ pub static WORD_ACH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -90814,14 +173799,24 @@ pub static WORD_ACH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["achilles"], &["achilles"], &["achilles"], - &["achieve"], + &["architecture"], + &["architectures"], &["achievable"], - &["achieved"], + &["achieve", "archive"], + &["achievable"], + &["achieved", "archived"], &["achieving"], &["achievement"], &["achievements"], + &["achiever", "archiver"], + &["achieves", "archives"], + &["achieving", "archiving"], + &["anchor"], + &["anchored"], + &["anchoring"], + &["anchors"], ], - range: 3..=9, + range: 2..=9, }; static WORD_ACF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90842,12 +173837,74 @@ static WORD_ACE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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: &[&["academia"], &["academic"], &["academically"]], - range: 5..=9, + values: &[ + &["access"], + &["academia"], + &["academic"], + &["academically"], + &["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 { @@ -90863,7 +173920,7 @@ static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_ACCE_NODE), None, None, - None, + Some(&WORD_ACCH_NODE), Some(&WORD_ACCI_NODE), None, None, @@ -90874,8 +173931,8 @@ static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str] Some(&WORD_ACCP_NODE), Some(&WORD_ACCQ_NODE), Some(&WORD_ACCR_NODE), - None, - None, + Some(&WORD_ACCS_NODE), + Some(&WORD_ACCT_NODE), Some(&WORD_ACCU_NODE), None, None, @@ -90899,21 +173956,47 @@ pub static WORD_ACCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("malate"), dictgen::InsensitiveStr::Ascii("malated"), 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("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"), @@ -90930,10 +174013,22 @@ pub static WORD_ACCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["accumulate"], &["accumulated"], &["accumulation"], + &["accumulator"], &["accumulate"], &["accumulated"], &["accumulate"], &["accumulated"], + &["accumulate"], + &["accumulated"], + &["accumulation"], + &["accumulate"], + &["accumulated"], + &["accumulates"], + &["accumulating"], + &["accumulator"], + &["accumulating"], + &["accumulators"], + &["accumulate"], &["accumulation"], &["accumulate"], &["accumulation"], @@ -90941,10 +174036,24 @@ pub static WORD_ACCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["accumulation"], &["accumulate"], &["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"], @@ -90952,7 +174061,34 @@ pub static WORD_ACCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["accustomed"], &["accustomed"], ], - range: 3..=8, + 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 { @@ -90962,24 +174098,48 @@ static WORD_ACCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("eting"), 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"], + &["accrediting"], + &["according"], + &["accordingly"], + &["acronym"], + &["acronyms"], &["according"], &["across"], + &["across"], + &["across"], ], - range: 3..=9, + range: 2..=9, }; static WORD_ACCQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -90988,9 +174148,21 @@ static WORD_ACCQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_ACCQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("uainted")], - values: &[&["acquainted"]], - range: 7..=7, + 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 { @@ -91000,122 +174172,80 @@ static WORD_ACCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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: 3..=6, + range: 2..=6, }; static WORD_ACCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ACCO_CHILDREN), + children: dictgen::DictTrieChild::Nested(&WORD_ACCO_CHILDREN), value: None, }; -pub static WORD_ACCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +static WORD_ACCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [ + None, + None, + None, + 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), + None, + 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("madate"), - dictgen::InsensitiveStr::Ascii("madated"), - dictgen::InsensitiveStr::Ascii("madates"), - dictgen::InsensitiveStr::Ascii("madating"), - dictgen::InsensitiveStr::Ascii("madation"), - dictgen::InsensitiveStr::Ascii("madations"), - dictgen::InsensitiveStr::Ascii("mdate"), - dictgen::InsensitiveStr::Ascii("mmadate"), - dictgen::InsensitiveStr::Ascii("mmadating"), - dictgen::InsensitiveStr::Ascii("mmadation"), - dictgen::InsensitiveStr::Ascii("mmidate"), - dictgen::InsensitiveStr::Ascii("mmidation"), - dictgen::InsensitiveStr::Ascii("modate"), - dictgen::InsensitiveStr::Ascii("modated"), - dictgen::InsensitiveStr::Ascii("modates"), - dictgen::InsensitiveStr::Ascii("modating"), - dictgen::InsensitiveStr::Ascii("modation"), - dictgen::InsensitiveStr::Ascii("modations"), - dictgen::InsensitiveStr::Ascii("mondate"), - dictgen::InsensitiveStr::Ascii("mondating"), - dictgen::InsensitiveStr::Ascii("mondation"), - dictgen::InsensitiveStr::Ascii("mpained"), - dictgen::InsensitiveStr::Ascii("mpanyed"), - dictgen::InsensitiveStr::Ascii("mpianed"), - dictgen::InsensitiveStr::Ascii("mpined"), - dictgen::InsensitiveStr::Ascii("mpinied"), - dictgen::InsensitiveStr::Ascii("mplise"), - dictgen::InsensitiveStr::Ascii("mplises"), - dictgen::InsensitiveStr::Ascii("mplishements"), - dictgen::InsensitiveStr::Ascii("mplishemnt"), - dictgen::InsensitiveStr::Ascii("mplishemnts"), - dictgen::InsensitiveStr::Ascii("mplishent"), - dictgen::InsensitiveStr::Ascii("mplishents"), - dictgen::InsensitiveStr::Ascii("mplishs"), - dictgen::InsensitiveStr::Ascii("mpliss"), - dictgen::InsensitiveStr::Ascii("mponied"), - dictgen::InsensitiveStr::Ascii("nplishment"), - dictgen::InsensitiveStr::Ascii("rdeon"), - dictgen::InsensitiveStr::Ascii("rdian"), - dictgen::InsensitiveStr::Ascii("ridng"), - dictgen::InsensitiveStr::Ascii("ring"), - dictgen::InsensitiveStr::Ascii("stumed"), - dictgen::InsensitiveStr::Ascii("untabillity"), - dictgen::InsensitiveStr::Ascii("untabilty"), - dictgen::InsensitiveStr::Ascii("untas"), - dictgen::InsensitiveStr::Ascii("untat"), - dictgen::InsensitiveStr::Ascii("untatns"), - dictgen::InsensitiveStr::Ascii("untent"), - dictgen::InsensitiveStr::Ascii("untents"), - dictgen::InsensitiveStr::Ascii("untt"), - dictgen::InsensitiveStr::Ascii("ustic"), + dictgen::InsensitiveStr::Ascii("nd"), + 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("t"), + dictgen::InsensitiveStr::Ascii("ting"), + dictgen::InsensitiveStr::Ascii("tn"), ], values: &[ - &["accommodate"], - &["accommodated"], - &["accommodates"], - &["accommodating"], - &["accommodation"], - &["accommodations"], - &["accommodate"], - &["accommodate"], - &["accommodating"], - &["accommodation"], - &["accommodate"], - &["accommodation"], - &["accommodate"], - &["accommodated"], - &["accommodates"], - &["accommodating"], - &["accommodation"], - &["accommodations"], - &["accommodate"], - &["accommodating"], - &["accommodation"], - &["accompanied"], - &["accompanied"], - &["accompanied"], - &["accompanied"], - &["accompanied"], - &["accomplishes"], - &["accomplishes"], - &["accomplishments"], - &["accomplishment"], - &["accomplishments"], - &["accomplishment"], - &["accomplishes"], - &["accomplishes"], - &["accomplishes"], - &["accompanied"], - &["accomplishment"], - &["accordion"], - &["accordion"], - &["according"], - &["according"], - &["accustomed"], + &["account"], &["accountability"], &["accountability"], &["accountants"], @@ -91125,8 +174255,270 @@ pub static WORD_ACCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["accountants"], &["accountant"], &["acoustic"], + &["acoustically"], + &["account"], + &["accounting"], + &["account"], ], - range: 4..=12, + 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("dinag"), + 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("ting"), + ], + values: &[ + &["according"], + &["accordion"], + &["accordion"], + &["according"], + &["according"], + &["accordingly"], + &["according"], + &["accordingly"], + &["according"], + &["accordingly"], + &["according"], + &["accordingly"], + &["according"], + &["according"], + &["accordingly"], + &["according", "occurring"], + &["accordingly"], + &["accordingly"], + &["accord"], + &["accordance"], + &["accorded"], + &["according"], + ], + range: 1..=7, +}; + +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"), + ], + values: &[&["according"], &["accordingly"]], + range: 5..=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("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("pt"), + ], + values: &[ + &["accommodate"], + &["accommodated"], + &["accommodates"], + &["accommodating"], + &["accommodation"], + &["accommodations"], + &["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"], + &["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_ACCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91137,10 +174529,22 @@ static WORD_ACCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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"], &["acclaimed"], &["acclimatization"]], + values: &[ + &["acclaimed"], + &["accelerated"], + &["accelerates"], + &["acceleration"], + &["accelerometers"], + &["acclaimed"], + &["acclimatization"], + ], range: 5..=11, }; @@ -91152,6 +174556,7 @@ static WORD_ACCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: 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("debtly"), @@ -91161,18 +174566,27 @@ pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic dictgen::InsensitiveStr::Ascii("dentely"), dictgen::InsensitiveStr::Ascii("dentes"), dictgen::InsensitiveStr::Ascii("dential"), + dictgen::InsensitiveStr::Ascii("dentially"), + dictgen::InsensitiveStr::Ascii("dentically"), 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"), ], values: &[ &["accidentally"], + &["accident"], &["accidentally"], &["accidentally"], &["accidentally"], @@ -91191,88 +174605,205 @@ pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["accidentally"], &["accidentally"], &["accidentally"], + &["accidentally"], + &["accidentally"], + &["accidentally"], + &["accidentally"], + &["accidental"], + &["accidentally"], + &["accident"], + &["accidental"], ], - range: 4..=8, + range: 3..=10, }; -static WORD_ACCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ACCE_CHILDREN), +static WORD_ACCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ACCH_CHILDREN), value: None, }; -pub static WORD_ACCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ACCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("dentally"), - dictgen::InsensitiveStr::Ascii("larate"), - dictgen::InsensitiveStr::Ascii("larated"), - dictgen::InsensitiveStr::Ascii("larating"), - dictgen::InsensitiveStr::Ascii("laration"), - dictgen::InsensitiveStr::Ascii("larator"), - dictgen::InsensitiveStr::Ascii("leartion"), - dictgen::InsensitiveStr::Ascii("lerade"), - dictgen::InsensitiveStr::Ascii("leraptor"), - dictgen::InsensitiveStr::Ascii("lerar"), - dictgen::InsensitiveStr::Ascii("lerare"), - dictgen::InsensitiveStr::Ascii("lerater"), - dictgen::InsensitiveStr::Ascii("leratie"), - dictgen::InsensitiveStr::Ascii("leratio"), - dictgen::InsensitiveStr::Ascii("lerato"), - dictgen::InsensitiveStr::Ascii("leraton"), - dictgen::InsensitiveStr::Ascii("leread"), - dictgen::InsensitiveStr::Ascii("lertor"), - dictgen::InsensitiveStr::Ascii("lleration"), - dictgen::InsensitiveStr::Ascii("lorate"), - dictgen::InsensitiveStr::Ascii("lorated"), - dictgen::InsensitiveStr::Ascii("lorating"), - dictgen::InsensitiveStr::Ascii("lorator"), - dictgen::InsensitiveStr::Ascii("nding"), - dictgen::InsensitiveStr::Ascii("nsion"), - dictgen::InsensitiveStr::Ascii("ptabel"), - dictgen::InsensitiveStr::Ascii("ptabelt"), - dictgen::InsensitiveStr::Ascii("ptabil"), - dictgen::InsensitiveStr::Ascii("ptence"), - dictgen::InsensitiveStr::Ascii("pterad"), - dictgen::InsensitiveStr::Ascii("ptes"), - dictgen::InsensitiveStr::Ascii("ptible"), - dictgen::InsensitiveStr::Ascii("relate"), - dictgen::InsensitiveStr::Ascii("sories"), - dictgen::InsensitiveStr::Ascii("ssable"), - dictgen::InsensitiveStr::Ascii("ssbile"), - dictgen::InsensitiveStr::Ascii("sseries"), - dictgen::InsensitiveStr::Ascii("ssibile"), - dictgen::InsensitiveStr::Ascii("ssibilty"), - dictgen::InsensitiveStr::Ascii("ssibily"), - dictgen::InsensitiveStr::Ascii("ssoire"), - dictgen::InsensitiveStr::Ascii("ssoires"), - dictgen::InsensitiveStr::Ascii("ssoirs"), - dictgen::InsensitiveStr::Ascii("sss"), + 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: &[ - &["accidentally"], - &["accelerate"], - &["accelerated"], - &["accelerating"], - &["acceleration"], - &["accelerator"], - &["acceleration"], - &["accelerated"], - &["accelerator"], - &["accelerator"], - &["accelerate"], - &["accelerator"], - &["accelerate"], - &["accelerator"], - &["acceleration"], - &["acceleration"], - &["accelerated"], - &["accelerator"], - &["acceleration"], - &["accelerate"], - &["accelerated"], - &["accelerating"], - &["accelerator"], - &["ascending"], - &["accession"], + &["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), + None, + 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("ed"), + dictgen::InsensitiveStr::Ascii("es"), + dictgen::InsensitiveStr::Ascii("ibility"), + dictgen::InsensitiveStr::Ascii("ible"), + 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("sable"), + dictgen::InsensitiveStr::Ascii("sbile"), + dictgen::InsensitiveStr::Ascii("series"), + dictgen::InsensitiveStr::Ascii("sibile"), + dictgen::InsensitiveStr::Ascii("sibiliity"), + dictgen::InsensitiveStr::Ascii("sibiliy"), + dictgen::InsensitiveStr::Ascii("sibilty"), + dictgen::InsensitiveStr::Ascii("sibily"), + dictgen::InsensitiveStr::Ascii("siblilty"), + dictgen::InsensitiveStr::Ascii("sile"), + dictgen::InsensitiveStr::Ascii("sintg"), + dictgen::InsensitiveStr::Ascii("sisble"), + 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("ssor"), + dictgen::InsensitiveStr::Ascii("ssors"), + ], + values: &[ + &["accessed"], + &["accesses"], + &["accessibility"], + &["accessible"], + &["accessing"], + &["accent"], + &["accessor"], + &["accessories"], + &["accessors"], + &["accessory"], + &["accessible"], + &["accessible"], + &["accessories"], + &["accessible"], + &["accessibility"], + &["accessibility", "accessible"], + &["accessibility"], + &["accessibility"], + &["accessibility"], + &["accessible"], + &["accessing"], + &["accessible"], + &["accessories", "accessory"], + &["accessories", "accessorise"], + &["accessorize", "accessories"], + &["accessories"], + &["accessor"], + &["access"], + &["accessor"], + &["accessors"], + ], + 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("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"), + ], + values: &[ + &["acceptable"], + &["accept"], + &["accepted"], + &["accept"], &["acceptable"], &["acceptable"], &["acceptable"], @@ -91280,20 +174811,131 @@ pub static WORD_ACCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic &["accepted"], &["accepts"], &["acceptable"], - &["accelerated"], - &["accessories"], - &["accessible"], - &["accessible"], - &["accessories"], - &["accessible"], - &["accessibility"], - &["accessibility"], - &["accessories"], - &["accessories"], - &["accessories"], - &["access"], ], - range: 3..=9, + range: 2..=6, +}; + +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("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("ertor"), + dictgen::InsensitiveStr::Ascii("lerated"), + dictgen::InsensitiveStr::Ascii("leration"), + dictgen::InsensitiveStr::Ascii("orate"), + dictgen::InsensitiveStr::Ascii("orated"), + dictgen::InsensitiveStr::Ascii("orating"), + dictgen::InsensitiveStr::Ascii("orator"), + ], + values: &[ + &["accelerate"], + &["accelerated"], + &["accelerating"], + &["acceleration"], + &["accelerator"], + &["accelerate"], + &["accelerated"], + &["accelerates"], + &["acceleration"], + &["accelerator"], + &["accelerated"], + &["accelerated"], + &["accelerator"], + &["accelerator"], + &["accelerate"], + &["accelerator"], + &["accelerate"], + &["accelerator"], + &["acceleration"], + &["acceleration"], + &["acceleration"], + &["acceleration"], + &["accelerated"], + &["accelerator"], + &["accelerated"], + &["acceleration"], + &["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("pted")], + values: &[&["accepted"]], + range: 4..=4, }; static WORD_ACCD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91313,9 +174955,67 @@ static WORD_ACCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen: }; pub static WORD_ACCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { - keys: &[dictgen::InsensitiveStr::Ascii("used")], - values: &[&["accused"]], - range: 4..=4, + keys: &[ + dictgen::InsensitiveStr::Ascii("ept"), + 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"], + &["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 { @@ -91328,9 +175028,19 @@ pub static WORD_ACCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dic 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"]], - range: 4..=5, + values: &[ + &["academic"], + &["academy"], + &["acclaimed"], + &["accept"], + &["accepted"], + &["accepts"], + ], + range: 2..=5, }; static WORD_ACA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91349,7 +175059,10 @@ pub static WORD_ACA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"], @@ -91361,9 +175074,12 @@ pub static WORD_ACA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["academics"], &["academics"], &["academics"], + &["academy"], &["academic"], + &["scale"], + &["academy"], ], - range: 4..=9, + range: 2..=9, }; static WORD_AB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91391,9 +175107,9 @@ static WORD_AB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]> None, Some(&WORD_ABR_NODE), Some(&WORD_ABS_NODE), - None, + Some(&WORD_ABT_NODE), Some(&WORD_ABU_NODE), - None, + Some(&WORD_ABV_NODE), None, None, Some(&WORD_ABY_NODE), @@ -91411,6 +175127,20 @@ pub static WORD_ABY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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, @@ -91419,9 +175149,13 @@ static WORD_ABU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"), @@ -91431,10 +175165,14 @@ pub static WORD_ABU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict ], values: &[ &["abundance"], + &["abundances"], &["abducted"], &["abundances"], &["abundances"], &["abundant"], + &["abundance"], + &["abundant"], + &["abundant"], &["abruptly"], &["abusers"], &["absurdity"], @@ -91444,107 +175182,569 @@ pub static WORD_ABU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict range: 3..=8, }; -static WORD_ABS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { - children: dictgen::DictTrieChild::Flat(&WORD_ABS_CHILDREN), +static WORD_ABT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { + children: dictgen::DictTrieChild::Flat(&WORD_ABT_CHILDREN), value: None, }; -pub static WORD_ABS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { +pub static WORD_ABT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable { keys: &[ - dictgen::InsensitiveStr::Ascii("ail"), - dictgen::InsensitiveStr::Ascii("ailing"), - dictgen::InsensitiveStr::Ascii("cence"), - dictgen::InsensitiveStr::Ascii("ense"), - dictgen::InsensitiveStr::Ascii("estos"), - dictgen::InsensitiveStr::Ascii("intence"), - dictgen::InsensitiveStr::Ascii("itnence"), - dictgen::InsensitiveStr::Ascii("loutes"), - dictgen::InsensitiveStr::Ascii("olue"), - dictgen::InsensitiveStr::Ascii("olument"), - dictgen::InsensitiveStr::Ascii("olutelly"), - dictgen::InsensitiveStr::Ascii("olutelys"), - dictgen::InsensitiveStr::Ascii("olutey"), - dictgen::InsensitiveStr::Ascii("olutisme"), - dictgen::InsensitiveStr::Ascii("olutiste"), - dictgen::InsensitiveStr::Ascii("olutley"), - dictgen::InsensitiveStr::Ascii("olutly"), - dictgen::InsensitiveStr::Ascii("oluts"), - dictgen::InsensitiveStr::Ascii("olvte"), - dictgen::InsensitiveStr::Ascii("oprtion"), - dictgen::InsensitiveStr::Ascii("orbes"), - dictgen::InsensitiveStr::Ascii("orbsion"), - dictgen::InsensitiveStr::Ascii("orbtion"), - dictgen::InsensitiveStr::Ascii("orpsion"), - dictgen::InsensitiveStr::Ascii("oulte"), - dictgen::InsensitiveStr::Ascii("oultely"), - dictgen::InsensitiveStr::Ascii("oultes"), - dictgen::InsensitiveStr::Ascii("ovle"), - dictgen::InsensitiveStr::Ascii("robs"), - dictgen::InsensitiveStr::Ascii("tanence"), - dictgen::InsensitiveStr::Ascii("tante"), - dictgen::InsensitiveStr::Ascii("tenance"), - dictgen::InsensitiveStr::Ascii("tenince"), - dictgen::InsensitiveStr::Ascii("tinense"), - dictgen::InsensitiveStr::Ascii("tinince"), - dictgen::InsensitiveStr::Ascii("traccion"), - dictgen::InsensitiveStr::Ascii("tracto"), - dictgen::InsensitiveStr::Ascii("traktion"), - dictgen::InsensitiveStr::Ascii("truction"), - dictgen::InsensitiveStr::Ascii("uers"), - dictgen::InsensitiveStr::Ascii("urditiy"), - dictgen::InsensitiveStr::Ascii("urdley"), - dictgen::InsensitiveStr::Ascii("urdy"), - dictgen::InsensitiveStr::Ascii("uridty"), - dictgen::InsensitiveStr::Ascii("ymal"), + 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: &[ - &["abseil"], - &["abseiling"], - &["absence"], - &["absence"], - &["asbestos"], - &["abstinence"], - &["abstinence"], - &["absolutes"], + &["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"], - &["absolute"], - &["absolutely"], - &["absolutes"], - &["absolutely"], - &["absolutes"], - &["absolutes"], - &["absolutely"], - &["absolutely"], - &["absolutes"], - &["absolve"], - &["absorption"], - &["absorbs"], - &["absorption"], - &["absorption"], - &["absorption"], - &["absolute"], - &["absolutely"], - &["absolutes"], - &["absolve"], - &["absorbs"], + &["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"], - &["abusers"], - &["absurdity"], - &["absurdly"], - &["absurdly"], - &["absurdity"], - &["abysmal"], ], - range: 3..=8, + 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("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"], + &["absolutely"], + &["absolute"], + &["absolute"], + &["absolutely"], + &["absolute"], + &["absolutely"], + &["absolute"], + &["absolutely"], + &["absolutes"], + &["absolutely"], + &["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("lutely"), + dictgen::InsensitiveStr::Ascii("lutly"), + dictgen::InsensitiveStr::Ascii("nse"), + dictgen::InsensitiveStr::Ascii("stos"), + ], + values: &[ + &["absolutely"], + &["absolutely"], + &["absence"], + &["asbestos"], + ], + range: 3..=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 { @@ -91556,11 +175756,15 @@ pub static WORD_ABR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -91570,11 +175774,15 @@ pub static WORD_ABR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict values: &[ &["abbreviate"], &["abbreviated"], + &["abbreviates"], + &["abbreviating"], &["abbreviation"], + &["abbreviations"], &["arbiter"], &["arbitrarily"], &["arbitrary"], &["arbitration"], + &["abbreviate"], &["abbreviation"], &["abruptly"], &["abruptly"], @@ -91591,8 +175799,12 @@ static WORD_ABO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -91602,6 +175814,8 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -91611,6 +175825,7 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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"), @@ -91620,11 +175835,28 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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("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"], @@ -91634,6 +175866,8 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["abandoning"], &["abandons"], &["abomination"], + &["about"], + &["abort", "aboard"], &["aboriginal"], &["aboriginal"], &["aboriginal"], @@ -91643,6 +175877,7 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["aboriginal"], &["aboriginal"], &["aboriginal"], + &["aborted", "abort", "aborts"], &["abortifacient"], &["absolute"], &["absolutely"], @@ -91652,9 +175887,22 @@ pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["absorbing"], &["absorbs"], &["absorption"], + &["absolute"], + &["absolutely"], + &["absolute"], + &["absolutely"], &["about"], + &["about"], + &["abort", "about"], + &["about"], + &["above"], + &["above"], + &["above"], + &["abovementioned"], + &["above"], + &["abovementioned"], ], - range: 2..=9, + range: 1..=10, }; static WORD_ABN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91668,14 +175916,18 @@ pub static WORD_ABN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict 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: 6..=7, + range: 3..=7, }; static WORD_ABI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91685,13 +175937,34 @@ static WORD_ABI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("ss"), + dictgen::InsensitiveStr::Ascii("trarily"), + dictgen::InsensitiveStr::Ascii("trate"), + dictgen::InsensitiveStr::Ascii("tration"), + dictgen::InsensitiveStr::Ascii("zmal"), ], - values: &[&["ability"], &["abilities"], &["ability"], &["ability"]], - range: 3..=5, + values: &[ + &["ambiguous"], + &["ambiguity"], + &["ability"], + &["abilities"], + &["abilities"], + &["ability"], + &["ability"], + &["abyss"], + &["arbitrarily"], + &["arbitrate"], + &["arbitration"], + &["abysmal"], + ], + range: 2..=7, }; static WORD_ABE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode { @@ -91728,28 +176001,60 @@ static WORD_ABB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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("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"], - &["about"], + &["abort", "abbot"], + &["aborted"], + &["aborting"], + &["aborts", "abbots"], + &["about", "abbot"], + &["abbreviation"], + &["abbreviate"], + &["abbreviation"], + &["abbreviations"], &["abbreviation"], &["abbreviation"], &["abbreviation"], &["abbreviation"], + &["abbreviations"], &["abbreviation"], &["abbreviation"], + &["abbreviate"], &["abbreviation"], + &["abbreviations"], ], range: 3..=10, }; @@ -91761,11 +176066,15 @@ static WORD_ABA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen:: 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"), @@ -91774,11 +176083,15 @@ pub static WORD_ABA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict dictgen::InsensitiveStr::Ascii("nonded"), ], values: &[ + &["available"], + &["abandon"], &["abandonment"], &["abandoning"], &["abandonment"], &["abandoned"], + &["abandoned"], &["abandoning"], + &["abandon"], &["abandoning"], &["abandonment"], &["abandoned"], @@ -91786,5 +176099,44 @@ pub static WORD_ABA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dict &["abandoning"], &["abandoned"], ], - range: 5..=8, + 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("ccessibility"), + dictgen::InsensitiveStr::Ascii("ccession"), + dictgen::InsensitiveStr::Ascii("ck"), + dictgen::InsensitiveStr::Ascii("ctual"), + dictgen::InsensitiveStr::Ascii("ctually"), + dictgen::InsensitiveStr::Ascii("dd"), + dictgen::InsensitiveStr::Ascii("ggregation"), + dictgen::InsensitiveStr::Ascii("nother"), + dictgen::InsensitiveStr::Ascii("pply"), + dictgen::InsensitiveStr::Ascii("re"), + dictgen::InsensitiveStr::Ascii("ssociated"), + dictgen::InsensitiveStr::Ascii("utomatic"), + dictgen::InsensitiveStr::Ascii("utomatically"), + ], + values: &[ + &["accessibility"], + &["accession"], + &["ack"], + &["actual"], + &["actually"], + &["add"], + &["aggregation"], + &["another"], + &["apply"], + &["are"], + &["associated"], + &["automatic"], + &["automatically"], + ], + range: 2..=12, }; diff --git a/crates/typos-dict/verify/src/main.rs b/crates/typos-dict/verify/src/main.rs index bd374e7..0a565a3 100644 --- a/crates/typos-dict/verify/src/main.rs +++ b/crates/typos-dict/verify/src/main.rs @@ -27,6 +27,19 @@ fn generate(file: &mut W, dict: &[u8]) { })); }); + let rows: Dict = rows + .into_iter() + .filter(|(t, _)| is_word(t)) + .filter_map(|(t, c)| { + let new_c: Vec<_> = c.into_iter().filter(|c| is_word(c)).collect(); + if new_c.is_empty() { + None + } else { + Some((t, new_c)) + } + }) + .collect(); + let disallowed_typos = varcon_words(); let word_variants = proper_word_variants(); let rows: Dict = rows @@ -67,6 +80,10 @@ fn generate(file: &mut W, dict: &[u8]) { wtr.flush().unwrap(); } +fn is_word(word: &str) -> bool { + word.chars().all(|c| c.is_alphabetic()) +} + fn varcon_words() -> HashSet> { // Even include improper ones because we should be letting varcon handle that rather than our // dictionary