 %***************************************************************************%
 %                                                                           %
 %       Copyright (C) 1991-1998  Daniel Sleator and Davy Temperley          %
 %  See file "README" for information about commercial use of this system    %
 %                                                                           %
 %***************************************************************************%

 % _ORGANIZATION OF THE DICTIONARY_
 % 
 % I. NOUNS
 % II. PRONOUNS
 % III. DETERMINERS
 % IV. NUMERICAL EXPRESSIONS
 % V. VERBS
 %    A. Auxiliaries; B. Common verb types; C. complex intransitive verbs; 
 %    D. complex intransitive verbs; E. complex verbs taking [obj] + 
 %    [complement]; F. idiomatic verbs
 % VI. PREPOSITIONS
 % VII. TIME AND PLACE EXPRESSIONS
 % VIII. QUESTION-WORDS AND CONJUNCTIONS
 % IX. ADJECTIVES
 % X. COMPARATIVES AND SUPERLATIVES
 % XI. ADVERBS
 %    A. Mainly adjectival; B. Mainly post-verbal; C. Post-verbal/pre-verbal;
 %    D. Post-verbal/pre-verbal/openers; E. Post-verbal/openers; 
 %    F. Pre-verbal/openers	
 % XII. MISCELLANEOUS WORDS AND PUNCTUATION 


% NOUNS

<CLAUSE>: {({@COd-} & C-) or ({@CO-} & (Wd- & {CC+})) or [Rn-]};

<S-CLAUSE>: {({@COd-} & C-) or ({@CO-} & (Wd- & {CC+}))}; 

<CLAUSE-E>: {({@COd-} & C-) or ({@CO-} & (Wd- or {CC+})) or Re-};

<noun-main-x>: (S+ & <CLAUSE>) or SI- or J- or O- or ({[B*j+]} & Xd- 
& (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main-s>: (Ss+ & <CLAUSE>) or SIs- or Js- or Os- or ({[Bsj+]} & Xd-
 & (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main-p>: (Sp+ & <CLAUSE>) or SIp- or Jp- or Op- or ({[Bpj+]} & Xd-
 & (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main-m>: (Ss+ & <CLAUSE>) or SIs- or Jp- or Os- or ({[Bsj+]} & Xd- 
& (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main-h>: (Ss*b+ & <CLAUSE>) or SIs*b- or Js- or Os- or ({[B*j+]} 
& Xd- & (Xc+ or [[[()]]]) & MX-) or [[[()]]];

<noun-main2-x>:  J- or O- or ({[B*j+]} & Xd- & (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main2-s>:  Js- or Os- or ({[Bsj+]} & Xd- & (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main2-p>:  Jp- or Op- or ({[Bpj+]} & Xd- & (Xc+ or [[[()]]]) & MX-) or [[[()]]];
<noun-main2-m>:  Jp- or Os- or ({[Bsj+]} & Xd- & (Xc+ or [[[()]]]) & MX-) or [[[()]]];

<noun-sub-x>: {@M+} & {R+ & B+ & {[[@M+]]}} & {@MX+};
<noun-sub-s>: {@M+} & {R+ & Bs+ & {[[@M+]]}} & {@MXs+};
<noun-sub-p>: {@M+} & {R+ & Bp+ & {[[@M+]]}} & {@MXp+};

CAPITALIZED-WORDS NAME: 
{G-} & {[MG+]} & (({DG- or [[GN-]] or [[{@A-} & {D-}]]} & 
(({@MX+} & (JG- or <noun-main-s>)) or YS+)) or AN+ or G+); 
% the generic category for words with a capitalized first character

PL-CAPITALIZED-WORDS: 
{G-} & {[MG+]} & (({DG- or [[GN-]] or [[{@A-} & {Dmc-}]]} & 
(({@MX+} & (JG- or <noun-main-x>)) or YS+ or YP+)) or AN+ or G+); 
% capitalized words ending in s

/en/words/words.n.p: % words that are also proper names
{G-} & {[MG+]} & (({DG- or [[GN-]] or [[{@A-} & {D-}]]} & 
(({@MX+} & (JG- or <noun-main-s>)) or (YS+ or YP+))) or AN+ or G+); 

I.n: [[{Xi+} & {G-} & G+]];

Ms.x Mrs.x Mr.x Rev.x Dr.x Prof.x Gov.x Sen.x Rep.x Gen.x Brig.x Col.x
Capt.x Lieut.x Lt.x Sgt.x Pvt.x Cmdr.x Adm.x Corp.x St.x Mt.x Ft.x:
(Xi+ or [[()]]) & G+;

St.y Ave.y Av.y Pl.y Ct.y Dr.y Gr.y Rd.y Blvd.y Pkwy.y Hwy.y Assn.y
Corp.y Co.y Inc.y Pty.y Ltd.y Bldg.y and_Co: G- & {Xi+} & {[MG+]} &
(({DG- or [[GN-]] or [[{@A-} & {D-}]]} & (({@MX+} & (JG- or
<noun-main-s>)) or (YS+ or YP+))) or AN+ or G+);

Jr.y Sr.y: {Xi+} & {Xd- & Xc+} & G- & {[MG+]} & (({DG- or
[[GN-]] or [[{@A-} & {D-}]]} & (({@MX+} & (JG- or <noun-main-s>)) or
(YS+ or YP+))) or AN+ or G+);

HYPHENATED-WORDS: ({EA- or EF+} & (({[[@Ec-]]} & {Xc+} & Ah+) or 
(Pa- & {@MV+}))) or [[AN+]]
or [[({@AN-} & {@A-} & (({D-} & <noun-sub-x> & (<noun-main-x> or B*m+)) or
 U-)) or ((YS+ or YP+) & {@AN-} & {@A-} & {D-})]];
% the generic category for strings containing a hyphen

/en/words/words.n.1: 
 ({@AN-} & {@A- & {[[@AN-]]}} & 
((Ds- & <noun-sub-s> & (<noun-main-s> or Bsm+))
or (YS+ & Ds-) or (GN+ & (DD- or [()])) or Us-)) or AN+;

/en/words/words.n.2.s:  % plural nouns ending in "s"
 ({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & <noun-sub-p> & 
(<noun-main-p> or Bpm+))
or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])) or Up-)) or [[AN+]];

/en/words/words.n.2.x:  % plural nouns not ending in "s"
 ({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & <noun-sub-p> & 
(<noun-main-p> or Bpm+))
or (YS+ & {Dmc-}) or (GN+ & (DD- or [()])) or Up-)) or [[AN+]];

/en/words/words.n.3:  % nouns that are mass only
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmu-} & <noun-sub-s> & 
(<noun-main-m> or Bsm+)) 
or (YS+ & {Dmu-}) or (GN+ & (DD- or [()])) or Up-)) or AN+;

/en/words/words.n.4:  % nouns that can be mass or countable
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & <noun-sub-s> & 
(<noun-main-m> or Bsm+)) or 
(YS+ & {D*u-}) or (GN+ & (DD- or [()])) or Us-)) or AN+;

/en/words/words.s: % US state names and abbreviations
({G-} & {DG- or [[GN-]] or [[{@A-} & {D-}]]} & 
(({MG+} & {@MX+} & (JG- or <noun-main-s>)) or G+ or 
({[[MG+]]} & (AN+ or YS+ or YP+)))) or (Xc+ & Xd- & G- & AN+);

alter_ego au_pair mise_en_scene faux_pas non_sequitur fait_accompli
modus_vivendi head_of_state tour_de_force:
 ({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & <noun-sub-s> & 
(<noun-main-s> or Bsm+))
or Us- or (YS+ & Ds-) or (GN+ & (DD- or [()])))) or AN+;

kung_fu joie_de_vivre op_art noblesse_oblige lese_majesty a_must
time_of_day time_of_year force_majeure top_dollar year_end skim_milk
breach_of_contract sleight_of_hand power_of_attorney word_of_mouth
carte_blanche: 
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmu-} & <noun-sub-s> & 
(<noun-main-m> or Bsm+)) or
Um- or (YS+ & {Dmu-}) or (GN+ & (DD- or [()])))) or AN+;

/en/words/words.n.t: % title nouns (president, chairman)
{@AN-} & {@A- & {[[@AN-]]}} & {@M+} & (BIt- or (Xd- & (Xc+ or [[[()]]]) & MX-) or TI-);

majority.n minority.n number.n bunch.n batch.n bulk.n handful.n group.n:
 ({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & <noun-sub-x> &
(<noun-main-x> or B*x+))
or Us- or (YS+ & Ds-) or (GN+ & (DD- or [()])))) or AN+;

flight.i age.i: {@AN-} & NIa+ & <noun-main-s>;

kind_of: ({{@AN-} & @A-} & U+ & ((Ds- & <noun-sub-s> &
(<noun-main-s> or Bsm+)) or Us-)) or EA+ or EE+;
type_of sort_of breed_of:
 {{@AN-} & @A-} & U+ & ((Ds- & <noun-sub-s> &
(<noun-main-s> or Bsm+)) or Us-);
kinds_of types_of sorts_of breeds_of:
 {{@AN-} & @A-} & U+ & (({Dmc-} & <noun-sub-p> & 
(<noun-main-p> or Bpm+)) or Up-);

percent.s: 
({@AN-} & {@A- & {[[@AN-]]}} & ((ND- & {DD-} & <noun-sub-x> & 
(<noun-main-x> or B*x+)) or
U-)) or (ND- & (OD- or AN+ or YS+));

argument.n report.n sign.n impression.n conclusion.n complaint.n
allegation.n announcement.n position.n restriction.n threat.n notion.n
remark.n assertion.n proclamation.n reassurance.n saying.n
accusation.n possibility.n idea.n problem.n claim.n result.n
statement.n hunch.n assumption.n concept.n hypothesis.n implication.n
message.n premonition.n prerequisite.n indication.n truism.n fallacy.n
proposition.n prospect.n presupposition.n inkling.n supposition.n
finding.n amount.n answer.n:
({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & {@M+} & {(TH+ or (R+ & Bs+)) & 
{[[@M+]]}} & {@MXs+} 
& (<noun-main2-s> or (Ss*t+ & <CLAUSE>) or SIs*t- or Bsm+))
or Us- or (YS+ & Ds-) or (GN+ & (DD- or [()])))) or AN+;

proof.n doubt.n suspicion.n hope.n knowledge.n relief.n 
disclosure.n fear.n acknowledgment.n acknowledgement.n principle.n
concern.n philosophy.n risk.n understanding.n conviction.n theory.n
assurance.n speculation.n awareness.n news.n opinion.n belief.n
contention.n thought.n myth.n discovery.n rumor.n probability.n fact.n
explanation.n feeling.n comment.n expectation.n perception.n sense.n
realization.n view.n insistence.n consensus.n notification.n rule.n
danger.n warning.n suggestion.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} & {(TH+ or (R+ & Bs+)) 
& {[[@M+]]}} & {@MXs+} & 
(<noun-main2-m> or (Ss*t+ & <CLAUSE>) or SIs*t- or Bsm+))
 or Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;  

evidence.n reasoning.n likelihood:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmu-} & {@M+} & {(TH+ or (R+ & Bs+)) 
& {[[@M+]]}} & {@MXs+} & 
(<noun-main2-m> or (Ss*t+ & <CLAUSE>) or SIs*t- or Bsm+)) 
 or Up- or (YS+ & {Dmu-}) or (GN+ & (DD- or [()])))) or AN+;  

ideas.n opinions.n statements.n beliefs.n facts.n arguments.n
principles.n theories.n philosophies.n signs.n impressions.n
conclusions.n contentions.n complaints.n proofs.n doubts.n
suspicions.n allegations.n reports.n claims.n announcements.n
positions.n risks.n hopes.n explanations.n restrictions.n threats.n
thoughts.n myths.n feelings.n discoveries.n rumors.n comments.n
realizations.n probabilities.n remarks.n notions.n convictions.n
hunches.n assumptions.n concepts.n hypotheses.n assertions.n
expectations.n implications.n perceptions.n proclamations.n
reassurances.n fears.n sayings.n senses.n messages.n disclosures.n
accusations.n views.n concerns.n understandings.n acknowledgments.n
acknowledgements.n possibilities.n premonitions.n prerequisites.n
provisos.n truisms.n fallacies.n assurances.n speculations.n
propositions.n prospects.n presuppositions.n inklings.n suppositions.n
findings.n amounts.n rules.n dangers.n warnings.n indications.n
answers.n suggestions.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {(TH+ or (R+ & Bp+)) & 
{[[@M+]]}} & {@MXp+} &
(<noun-main2-p> or (Sp*t+ & <CLAUSE>) or SIp*t- or Bpm+))
or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];

request.n requirement.n condition.n recommendation.n provision.n stipulation.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} & {(TH+ or TS+ or (R+ & Bs+)) 
& {[[@M+]]}} & {@MXs+} & 
(<noun-main2-m> or (Ss*t+ & <CLAUSE>) or SIs*t- or Bsm+))
 or Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;  
requests.n requirements.n conditions.n recommendations.n provisions.n
stipulations.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {(TH+ or TS+ or (R+ & Bp+)) & 
{[[@M+]]}} & {@MXp+} &
(<noun-main2-p> or (Sp*t+ & <CLAUSE>) or SIp*t- or Bpm+))
or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];

excuse.n decision.n proposal.n attempt.n plan.n pledge.n urge.n
mission.n right.n desire.n mandate.n promise.n option.n campaign.n
offer.n vow.n permit.n impetus.n proclivity.n propensity.n move.n
vote.n bill.n:
({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & {@M+} & {(TOn+ or (R+ & Bs+)) & 
{[[@M+]]}} & {@MXs+} & (<noun-main-s> or Bsm+)) or
 Us- or (YS+ & Ds-) or (GN+ & (DD- or [()])))) or AN+;
failure.n haste.n refusal.n reluctance.n pressure.n willingness.n
responsibility.n intent.n temptation.n readiness.n effort.n
determination.n capacity.n unwillingness.n need.n will.n eagerness.n
opportunity.n commitment.n ambition.n ability.n order.n obligation.n
incentive.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} & {(TOn+ or (R+ & Bs+)) & 
{[[@M+]]}} & {@MXs+} & (<noun-main-m> or Bsm+)) or
 Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
excuses.n decisions.n proposals.n failures.n efforts.n attempts.n refusals.n pledges.n
urges.n missions.n rights.n desires.n needs.n ambitions.n capacities.n mandates.n
promises.n abilities.n options.n commitments.n intents.n opportunities.n plans.n
responsibilities.n chances.n campaigns.n offers.n pressures.n obligations orders.n
temptations.n vows.n permits.n impetuses.n proclivities.n propensities.n moves.n 
votes.n bills.n incentives.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {(TOn+ or (R+ & Bp+)) &
 {[[@M+]]}} & {@MXp+} & (<noun-main-p> or Bpm+)) or
 Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];
chance.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} & {(TOn+ or TH+ or (R+ & Bs+)) 
& {[[@M+]]}} & {@MXs+} & (<noun-main-m> or Bsm+)) or 
 Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
question.n issue.n: 
({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & {@M+} & {R+ & Bs+ & {[[@M+]]}} & 
{@MXs+} &
(<noun-main2-s> or (Ss*q+ & <CLAUSE>) or SIs*q- or Bsm+))
or Us- or (YS+ & Ds-) or (GN+ & (DD- or [()])))) or AN+;
questions.n issues.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {R+ & Bp+ & {[[@M+]]}} & 
{@MXp+} &
(<noun-main2-p> or (Sp*q+ & <CLAUSE>) or SIp*q- or Bpm+))
or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or AN+;

week.n moment.n hour.n minute.n year.n instant.n period.n month.n 
second.n decade.n century.n:
({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & {@M+} &
{WN+ or TH+ or [[Ce+]] or (R+ & Bs+)} & {@MXs+} & 
(<noun-main-s> or Bsm+)) or 
 Us- or (YS+ & Ds-) or (GN+ & (DD- or [()])))) or AN+;
day.n night.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} &
{WN+ or TH+ or [[Ce+]] or (R+ & Bs+)} & {@MXs+} & 
(<noun-main-m> or Bsm+)) or 
 Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
days.n weeks.n moments.n hours.n minutes.n years.n instants.n periods.n months.n
nights.n seconds.n decades.n centuries.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {WN+ or TH+ or Ce+ or 
(R+ & Bp+)}  & {@MXp+} & (<noun-main-p> or Bpm+)) 
or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];
reason.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} & {TH+ or Ce+ or TOn+ or 
WY+ or (R+ & Bs+)} & {@MXs+} & 
(<noun-main2-s> or (Ss*t+ & <CLAUSE>) or SIs*t- or Bsm+))
or Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
reasons.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {TH+ or Ce+ or TOn+ or
 WY+ or (R+ & Bp+)} & {@MXp+} & (<noun-main-p> or Bpm+))
 or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];
way.n:
({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & {@M+} & {TOn+ or TH+ or Ce+ or 
(R+ & Bs+)} & {@MXs+} & (MVa- or <noun-main-s> or Bsm+))
or Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
place.n:
({@AN-} & {@A- & {[[@AN-]]}} & ((Ds- & {@M+} & {TOn+ or TH+ or Ce+ or 
(R+ & Bs+)} & {@MXs+} & (<noun-main-s> or Bsm+))
or Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
time.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & {@M+} & {TOn+ or WN+ or TH+ or 
Ce+ or (R+ & Bs+)} & {@MXs+} & (<noun-main-m> or Bsm+))
or Us- or (YS+ & {D*u-}) or (GN+ & (DD- or [()])))) or AN+;
ways.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {TOn+ or TH+ or Ce+ or 
(R+ & Bp+)} & {@MXp+} & (MVa- or <noun-main-p> or Bpm+))
or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];
places.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {TOn+ or TH+ or Ce+ or 
(R+ & Bp+)} & {@MXp+} & (<noun-main-p> or Bpm+))
 or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];
times.n:
({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & {@M+} & {TOn+ or WN+ or TH+ or 
Ce+ or (R+ & Bp+)} & {@MXp+} & (<noun-main-p> or Bpm+))
 or Up- or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])))) or [[AN+]];


%PRONOUNS

she he: ({[[R+ & Bs+]]} & ((Ss+ & <CLAUSE>) or SIs-));
me him them us: J- or Ox-;
myself yourself himself herself itself themselves
ourselves yourselves: J- or O- or E+ or MVa-;
each_other: J- or O- or YS+;
her.d: ({AL-} & {@L+} & (D+ or DD+)) or DP+;
her.p: J- or Ox-;
its my your their our: ({AL-} & {@L+} & (D+ or DD+)) or DP+;
his: DP+ or ({AL-} & {@L+} & (D+ or DD+)) or
[<noun-main-x>];
you: J- or Ox- or (Sp+ & <CLAUSE>) or SIp-;
it: J- or Ox- or ((Ss+ or SFsi+) & <CLAUSE>) or SIs- or 
SFIsi- or OXi- or Vp-;
they: {[[R+ & Bp+]]} & ((Sp+ & <CLAUSE>) or SIp-);
we: (Sp+ & <CLAUSE>) or SIp-;
I.p: ((Sp*i+ or SX+) & <CLAUSE>) or SIp*i- or SXI-;

it_all them_all us_all you_all: Ox- or J-;

%we're they're I'm you're: 
%(({@EBm+} & (((O*t+ or K+ or BI+ or OF+ or Pp+) & {@MV+}) or TO+ or Pa+)) or 
%({N+} & (Pg+ or Pv+))) & <CLAUSE>;

'm: SX- & (({@EBm+} & (((O*t+ or K+ or BI+ or OF+ or Pp+) & {@MV+}) or TO+ or Pa+)) or 
({N+} & (Pg+ or Pv+)));
're: Spx- & (({@EBm+} & (((O*t+ or K+ or BI+ or OF+ or Pp+) & {@MV+}) or TO+ or Pa+)) or 
({N+} & (Pg+ or Pv+)));

%I've they've you've we've: PP+ & <CLAUSE>;

've: Sp- & PP+;

%we'd they'd I'd he'd she'd you'd: (PP+ or ({Vw+} & I+)) & <CLAUSE>;
%I'll he'll she'll we'll they'll you'll it'll: I+ & <CLAUSE>;

'd: Sp- & (PP+ or I+);
'll: S- & I+;

something someone somebody:
{EL+} & (({Pa+} & <noun-sub-s> & {@MXs+} & <noun-main-s>) or YS+);
nothing no_one nobody:
{EN-} & {EL+} & (({Pa+} & <noun-sub-s> & {@MXs+} &
<noun-main-s>) or YS+);
everything everyone anyone everybody anybody anything: 
{EN-} & {EL+} & (((({Pa+} & <noun-sub-s>) or CX+) & {@MXs+} &
<noun-main-s>) or YS+);
nothing_but: Vd- & I+;
else: EL-;

others: {Dmc-} & <noun-sub-p> & <noun-main-p>;
mine.p yours theirs hers ours: <noun-main-x>;


% DETERMINERS

the: ({AL-} & {@L+} & (D+ or DD+)) or DG+ or (TR- & U+);
those: ({AL-} & (Dmc+ or DD+)) or 
(<noun-sub-p> & <noun-main-p>);
this.p: <noun-main-h>;
this.d: ({AL-} & D*u+) or DTn+;
these: <noun-main-p> or ({AL-} & (Dmc+ or DD+));
both: Dmc+ or E+ or ({M+ or (ALx+ & Jp+)} & <noun-main-p>);
half: {EN-} & (NJ+ or ((({DD-} & {@Mp+ or (R+ & B+)}) or (AL+ & J+))
& <noun-main-x>));
many: (H- & (Dmc+ or ND+ or TQ+)) or (AM- & (Dmcy+ or Oy- or Jy-)) or 
({EE-} & ND+) or ({DD-} & {EAx-} & Dmc+) or ((({EAx-} & {DD-}) or H-) & 
<noun-sub-p> & (<noun-main-p> or Bpm+));
all: ({EN-} & (E+ or Dm+ or NIc+ or 
({@M+ or (ALx+ & Jp+) or (R+ & B+) or EL+} & 
(<noun-main2-x> or (S**t+ & <CLAUSE>) or SI**t-)))) or DTa+;
all_that: EA+ or EE+ or (<noun-sub-s>
 & <noun-main-s>);
all_this: <noun-sub-s> & <noun-main-s>;
all_those all_these: <noun-sub-p> & <noun-main-p>;
one: NN+ or ({EN-} & (({DD-} & Ds+) or ({{@A- & {[[@AN-]]}} & Ds-} & 
(YS+ or (<noun-sub-s> & (<noun-main-s> or Bsm+)))))) or NSn+ or DTi+;
ones: {@A- & {[[@AN-]]}} & {Dmc-} & 
(YP+ or (<noun-sub-p> & <noun-main-p>));
any: ({EN-} & (D+ or DD+ or 
(<noun-sub-x> & <noun-main-x>))) or EC+;
a an: ({(AA- & HA-) or ALa- or [[Lf+]]} & Ds+) or NN+ or NSa+;
such: (ND- & Dmc+) or Dm*k+;
such_a such_an: Ds*k+;

a_lot: (<noun-sub-p> & <noun-main-p>) or EC+ or MVa-;
few: {EA- or EF+ or ({EA-} & DD-)} & 
 (Dmc+ or (<noun-sub-p> & <noun-main-p>));
a_couple: <noun-sub-p> & <noun-main-p>;
a_couple_of: NN+ or ND+;
a_few: NN+ or ND+ or ({EN-} & (Dmc+ or ND+ or 
(<noun-sub-p> & <noun-main-p>)));
some: D+ or EN+ or MF+ or (<noun-sub-x> & <noun-main-x>);
little.i: ({EE-} & (MVa- or Ca+ or Qe+)) or ({EEx- or H-} & (Dmu+ or 
(<noun-sub-s> & (<noun-main-s> or Bsm+))))
or (AM- & (Dmuy+ or MVy- or Oy- or Jy-));
most: Dm+ or [EE+] or EA+ or MF+ or
(<noun-sub-x> & <noun-main-x>);
part.i: OF+ & <noun-main-s>;

the_most: MVa- or EE+ or Dm+ or (<noun-sub-x> & <noun-main-x>);
least: EA+; 
none: <noun-sub-x> & (<noun-main-x>);
rest.i: (DG-) & <noun-sub-p> & <noun-main-p>;
plenty: {@M+} & <noun-main-x>;
other: Dmu+ or ({ND-} & {DD-} & Dmc+) or 
(DD- & (Ds+ or DD+ or <noun-main-s>));
one_other every_other: <noun-main-s> or Ds+; 
any_other no_other: <noun-main-s> or D+;
all_other: Dm+;
most_other: Dmc+;
quite_a quite_an one_such not_every: Ds+;
some_other no_such: D+;
every.d: {EN-} & (Ds+ or DTn+ or [[NIc+]]); 

another: Ds+ or NIc+ or (<noun-sub-s> & <noun-main-s>) or YS+;
one_another: (<noun-sub-s> & <noun-main-s>) or YS+;
each: Ds+ or (<noun-sub-s> & <noun-main-s>) or DTn+
or E+ or MVa-;
no.d: ({EN-} & D+) or EC+;
a_little: Dmu+ or (<noun-sub-s> & <noun-main-s>)
or EA+ or EC+ or EE+ or MVa-;
a_great_deal: EC+ or MVa- or (<noun-sub-s> & <noun-main-s>);
many_more a_few_more a_couple_more plenty_more a_lot_more:
Dmcc+ or (<noun-sub-p> & <noun-main-p>);
some_more: MVa- or Dm+ or (<noun-sub-x> & <noun-main-x>);
one_more:
Ds+ or (<noun-sub-s> & <noun-main-s>);

not_many: Dmc+ or (<noun-sub-p> & (Sp+ & <CLAUSE>));
not_all: Dm+ or (((ALx+ & Jp+) or <noun-sub-x>)
& (S+ & <CLAUSE>));
not_one: Ds+ or (<noun-sub-s> & (Ss+ & <CLAUSE>));

enough: ({OF+} & <noun-main-s>) or Dm+ or EF- or MVa-;
not_enough: ({OF+} & <noun-main-s>) or Dm+;

% NUMERICAL EXPRESSIONS

two three four five six seven eight nine ten eleven twelve thirteen
fourteen fifteen sixteen seventeen eighteen nineteen twenty thirty forty
fifty sixty seventy eighty ninety several: 
NN+ or NW+ or NIa- or
({EN- or NIc-} & (ND+ or ({{@L+} & DD-} & 
(Dmc+ or (<noun-sub-p> & <noun-main-p>)))));

NUMBERS: % the generic "number" category
NN+ or NIa- or [[NF+]] or ({EN- or NIc-} & (ND+ or OD- or 
({{@L+} & DD-} & (Dmcn+ or (<noun-sub-p> & <noun-main-p>)))))
or [[G- & (({MXs+} & <noun-main-s>) or G+ or AN+ or YS+)]];

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 
29 30 31:
NN+ or NIa- or [[NF+]] or ({EN- or NIc-} & (ND+ or OD- or ({{@L+} & DD-} &  
(Dmcn+ or (<noun-sub-p> 
 & <noun-main-p>))))) or TM- or [[G- & (({MXs+} & <noun-main-s>) or G+ or AN+ or YS+)]];

1: NN+ or NIa- or [[NF+]] or ({EN- or NIc-} & (ND+ or OD- or ({{@L+} & DD-} 
& (D**n+ or (<noun-sub-x> & <noun-main-x>))))) or TM-
or [[G- & (({MXs+} & <noun-main-s>) or G+ or AN+ or YS+)]] or NSn+;

0: NN+ or NIa- or [[NF+]] or
({EN- or NIc-} & (ND+ or OD- or ({{@L+} & DD-} &  
(Dmcn+ or [[Ds+]] or (<noun-sub-p> & <noun-main-p>))))) 
or [[G- & (({MXs+} & <noun-main-s>) or G+ or AN+ or YS+)]] or NSn+;

fiscal.i: TY+ & <noun-main-s>;

or_so: ND- & {{@L+} & DD-} & (Dmcn+ or (<noun-sub-p> & <noun-main-p>));

/en/words/words.y:  % year numbers
NN+ or NIa- or AN+ or 
((Xd- & TY- & Xc+) or TY-) 
or ({EN- or NIc-} & (ND+ or OD- or ({{@L+} & DD-} &  
([[Dmcn+]] or ((<noun-sub-x> or TA-) & (JT- or IN- or [[<noun-main-x>]]))))));

1900s 1910s 1920s 1930s 1940s 1950s 1960s 1970s 1980s 1990s
1900's 1910's 1920's 1930's 1940's 1950's 1960's 1970's 1980's 1990's
'20s '30s '40s '50s '60s '70s '80s '90s: {TA-} & DG- & <noun-main-x>;

hundred thousand million billion trillion dozen:
NN- & (NNy+ or NIa- or
({EN- or NIc-} & (ND+ or OD- or ({{@L+} & DD-} &  
(Dmcn+ or (<noun-sub-p> & <noun-main-p>))))));
half_a_dozen half_a_million: NIa- or
({EN- or NIc-} & (ND+ or OD- or ({{@L+} & DD-} &  
(Dmcn+ or (<noun-sub-p> & <noun-main-p>)))));

hundreds thousands millions billions trillions dozens:
({DD-} & <noun-sub-p> & <noun-main-p>);
tens: {DD-} & OF+ & <noun-main-p>;
hundreds_of thousands_of millions_of billions_of trillions_of dozens_of: ND+;

1/2 3/4 2/3 1/3 1/4 1/8 3/8 5/8 7/8: 
({NNx-} & NNy+) or NIa- or NF+ or NIe+ 
or ({NNx-} & {EN- or NIc-} & (ND+ or OD- or ({DD-} & 
([[Ds+]] or Dmcn+ or (<noun-sub-x> & <noun-main-x>)))));

and_a_half: (NW- or NSn-) & 
(NNy+ or NIa- or ({EN- or NIc-} & (ND+ or ({DD-} & 
(Dmcn+ or (<noun-sub-p> & <noun-main-p>))))));

third fourth fifth sixth seventh eighth ninth tenth eleventh
twelfth thirteenth fourteenth fifteenth sixteenth seventeenth eighteenth
nineteenth:
L- or Pa- or MVa- or ({Xc+ & {Xd-}} & CO+) or 
(NS- & {EN-} & NF+) or (((NS- & <noun-sub-x> & {EN-}) or 
(DD- & <noun-sub-x> & {TOn+})) & <noun-main-x>) or NR+;
second.a: L- or Pa- or MVa- or ({Xc+ & {Xd-}} & CO+) or 
(DD- & <noun-sub-x> & {TOn+} & <noun-main-x>) or NR+;
quarter.i:
NS- & {EN-} & (NF+ or (<noun-sub-x> & <noun-main-x>));
thirds.m fourths.m quarters.m fifths.m sixths.m sevenths.m eighths.m 
ninths.m tenths.m:
NW- & {EN-} & (NF+ or (<noun-sub-x> & <noun-main-x>));

first.a: 
L- or Pa- or E+ or MVa- or ({Xc+ & {Xd-}} & CO+) or
TT+ or ((DD- or [[NSa-]]) & <noun-sub-x> & {TOn+} & <noun-main-x>);
last.a: L- or Pa- or MVa- or ({Xc+ & {Xd-}} & CO+) or 
DTi+ or TT+ or (DD- & <noun-sub-x> & {TOn+} & <noun-main-x>);

%VERBS

% These are the verb-form expressions for ordinary verbs.

<verb-pl,i>: {@E-} & (Sp- or (RS- & Bp-) or I- or Wi-);
<verb-pl>: {@E-} & (Sp- or (RS- & Bp-));
<verb-s>: {@E-} & (Ss- or (RS- & Bs-));
<verb-i>: {@E-} & I-;
<verb-sp,pp>: {@E-} & (S- or (RS- & B-) or PP-);
<verb-sp>: {@E-} & (S- or (RS- & B-));
<verb-pp>: {@E-} & PP-;
<verb-pg>: {@E-} & (Pg- or Mg-);
<verb-pv>: {@E-} & (Pv- or Mv-) & {@MV+};
<verb-pv-b>: {@E-} & (Pv- or Mv-);
<verb-ge>: {@E-} & ((Xd- & (Xc+ or [[[()]]]) & (MX*p- or MVg-)) or 
({[DP-]} & ((Ss*g+ & <CLAUSE>) or SIs*g- or [[[()]]])) 
or [DP- & J-] or [[Wq- & PF+]] or ({Xd-} & Xc+ & COp+));

<verb-ge-d>: ({@AN-} & {@A- & {[[@AN-]]}} & (Dmu- or [[()]]) & 
(OF+ or [[()]]) 
& <noun-sub-s> & {@MXs+} & ((Ss+ & <CLAUSE>) or SIs- or Os- or J-)) 
or [[AN+]];

<verb-pg,ge>: {@E-} & (({[DP-]} & ((Ss*g+ & <CLAUSE>) or SIs*g- 
or [[[()]]])) or 
Mg- or Pg- or (Xd- & (Xc+ or [[[()]]]) & (MX*p- or MVg-)) 
or [DP- & J-] or [[Wq- & PF+ & {@MV+}]] or ({Xd-} & Xc+ & COp+));

<verb-po>: {@E-} & {@MV+} & ((Xd- & (Xc+ or [[[()]]]) & (MX*p- or MVg-))
 or [[Wq- & PF+ & {@MV+} & {CC+}]] or ({Xd-} & Xc+ & COp+)); 

% These are the verb-form expressions for special verbs that can take
% filler-"it" as a subject.

<verb-s-pl,i>: {@E-} & (Sp- or If- or (RS- & Bp-) or Wi-);
<verb-s-s>: {@E-} & (Ss- or SFsi- or (RS- & Bs-));
<verb-s-sp,pp>: {@E-} & (S- or SFsi- or PPf- or (RS- & B-));
<verb-s-sp>:  {@E-} & (S- or SFsi- or (RS- & B-));
<verb-s-pp>: {@E-} & PPf-;
<verb-s-pg>: {@E-} & (Pgf- or Mg-);
<verb-s-pv>: {@E-} & (Pvf- or Mv-) & {@MV+};
<verb-s-pv-b>: {@E-} & (Pvf- or Mv-);

% These are the verb-form expressions for special verbs that can take 
% either filler-"it" or filler-"there" as a subject.

<verb-x-pl,i>: {@E-} & (Sp- or SFp- or  If- or (RS- & Bp-) or Wi-);
<verb-x-s>: {@E-} & (Ss- or SFs- or (RS- & Bs-));
<verb-x-sp,pp>: {@E-} & (S- or SF- or (RS- & B-) or PPf-);
<verb-x-pp>: {@E-} & PPf-;
<verb-x-pg>: {@E-} & (Pgf- or Mg-);
<verb-x-pg,ge>: {@E-} & (Pgf- or Mg- or ({[DP-]} & ((Ss*g+ & <CLAUSE>) 
or SIs*g- or [[[()]]])) or (Xd- & (Xc+ or [[[()]]]) & (MX*p- or MVg-)) 
or [DP- & J-] or [[Wq- & PF+ & {@MV+}]] or ({Xd-} & Xc+ & COp+));
<verb-x-sp>: {@E-} & (S- or SF- or (RS- & B-));


% AUXILIARY VERBS

<vc-do>: (((B- or O+ or [[@MV+ & O*n+]] or Vd+ or ({N+} & (CX- or [[()]]))) & {@MV+}) 
or ({N+} & I*d+));
do.v: ({@E-} & (Sp- or SFp- or (RS- & Bp-) or Wi-) & <vc-do>)
or ((SIp+ or SFIp+) & (({Q-} & I*d+) or CQ-)) or 
({@E-} & I- & ((B- or O+ or [[@MV+ & O*n+]] or CX-) & {@MV+}));
does.v: (<verb-x-s> & <vc-do>) or ((SIs+ or SFIs+) & (({Q-} & I*d+) or CQ-));
did.v: (<verb-x-sp> & <vc-do>) or ((SI+ or SFI+) & (({Q-} & I*d+) or CQ-));
done.v: (<verb-pp> & (B- or O+ or [[@MV+ & O*n+]] or Vd+)) or <verb-pv> or <verb-po>;
doing.v: <verb-pg> & (O+ or B- or [[@MV+ & O*n+]] or Vd+) & {@MV+};
doing.g: ((O+ or B- or [[@MV+ & O*n+]] or Vd+) & {@MV+} & <verb-ge>) or <verb-ge-d>;
fine.i: Vd-;

don't: (({Q-} & (SIp+ or SFIp+) & I*d+) or ({@E-} & (Sp- or SFp- or
(RS- & Bp-) or Wi-))) & (I*d+ or [[()]]);
doesn't: (({Q-} & (SIs+ or SFIs+) & I*d+) or <verb-x-s>) & 
(I*d+ or [[()]]);
didn't: (({Q-} & (SI+ or SFI+)) or ({@E-} & (S- or SF- or
(RS- & B-)))) & (I*d+ or [[()]]);

<vc-have>: ({@MV+} & TO+) or ((B- or O+) & {@MV+} & {[I*j+ or Pv+]})
or (([[@MV+ & O*n+]] or CX- or [[()]]) & {@MV+}) or ({N+} & PP+);
have.v: ((SIp+ or SFIp+) & (({Q-} & PP+) or CQ-)) or (<verb-x-pl,i> &
 <vc-have>);
has.v: ((SIs+ or SFIs+) & (({Q-} & PP+) or CQ-)) or (<verb-x-s> & <vc-have>);
had.v: ((SI+ or SFI+) & (({Q-} & PP+) or CQ-)) or (<verb-x-sp> & <vc-have>)
or (<verb-x-pp> & (TO+ or ((B- or O+) & {@MV+} & {[I*j+ or Pv+]}) or 
(([[@MV+ & O*n+]] or CX-) & {@MV+}))) or 
[[(SI*j+ or SFI**j+) & PP+ & 
((Xd- & CCq- & Xc+) or CCq- or ({{Xd-} & Xc+} & COp+))]];
having.v: <verb-pg> & <vc-have>;
having.g: (<vc-have> & <verb-ge>) or <verb-ge-d>;

hasn't: (({Q-} & (SIs+ or SFIs+)) or (<verb-x-s>)) &
(PP+ or ([[O+]] & {@MV+}) or [[()]]);
haven't: (({Q-} & (SIp+ or SFIp+)) or ({@E-} & (Sp- or SFp- or 
(RS- & Bp-)))) & (PP+ or ([[O+]] & {@MV+}) or [[()]]);
hadn't: (({Q-} & (SI+ or SFI+)) or ({@E-} & 
(S- or SFs- or SFp- or (RS- & B-)))) &
(PP+ or ([[O+]] & {@MV+}) or [[()]]);

<vc-be>: ({@EBm+} & (((O*t+ or [B**t-] or K+ or BI+ or OF+ or PF- or 
(Osi+ & R+ & Bs+) or (Opi+ & R+ & Bp+) or [[()]]) & {@MV+})
or (Pp+ & {THi+ or @MV+}) or THb+ or TO+ or Pa+)) or 
({N+} & (AF- or Pg*b+ or Pv+));
is.v: ((<verb-x-s>) or 
({Q-} & (SIs+ or SFIs+))) & <vc-be>;
's.v: [[<verb-x-s> & 
(({@EBm+} & (((O*t+ or K+ or BI+ or OF+ 
or (Osi+ & R+ & Bs+) or (Opi+ & R+ & Bp+)) & {@MV+})
or (Pp+ & {THi+ or @MV+}) or THb+ or TO+ or Pa+)) or Pg+ or Pv+ or PP+)]];
was.v: (({@E-} & (Ss- or SX- or SFs- or (RS- & Bs-))) or ({Q-} &
(SFIs+ or SIs+ or SXI+))) & <vc-be>;
are.v: (({@E-} & (Spx- or SFp- or (RS- & Bp-))) or ({Q-} & 
(SIpx+ or SFIp+))) & <vc-be>;
were.v: ((({@E-} & (Spx- or SFp- or [[Ss-]] or [[SX-]] or 
(RS- & Bp-))) or ({Q-} & 
(SIpx+ or SFIp+))) & <vc-be>) or [[(SI*j+ or SFI**j+) & <vc-be> &
((Xd- & CCq- & Xc+) or CCq- or ({{Xd-} & Xc+} & COp+))]];
am.v: (({@E-} & SX-) or ({Q-} & SXI+)) & <vc-be>;
be.v: {@E-} & (Ix- or Wi-) & <vc-be>;
been.v: {@E-} & PPf- & <vc-be>;
being.v: ((({@EBm+} & (((O*t+ or [B**t-] or Pp+ or K+ or OF+ or BI+
or TO+ or THb+) & {@MV+}) or Pa+)) or AF- or Pv+) & <verb-pg,ge>) or 
<verb-ge-d>;

isn't: (<verb-x-s> or 
({Q-} & (SIs+ or SFIs+))) & <vc-be>;
wasn't: (({@E-} & (Ss- or SX- or SFs- or (RS- & Bs-))) or ({Q-} &
(SI*+ or SXI+ or SFIs+))) & <vc-be>;
aren't weren't: (({@E-} & (Spx- or SFp- or (RS- & Bp-))) or 
({Q-} & (SIpx+ or SFIp+))) & <vc-be>;

will.v can.v may.v must.v could.v might.v shall.v: 
((SI+ or SFI+) & (({Q-} & I+) or CQ-)) or
({N+} & {@E-} & (S- or SF- or (RS- & B-)) & (I+ or (CX- & {@MV+})
or [[()]]));
should.v: ((SI+ or SFI+) & (({Q-} & I+) or CQ-)) or
({N+} & {@E-} & (S- or SF- or (RS- & B-)) & (I+ or (CX- & {@MV+})
or [[()]])) or [[(SI*j+ or SFI**j+) & I+ & 
((Xd- & CCq- & Xc+) or CCq- or ({{Xd-} & Xc+} & COp+))]];
would.v: ((SI+ or SFI+) & (({Q-} & {Vw+} & I+) or CQ-)) or
({N+} & {@E-} & (S- or SF- or (RS- & B-)) & (({RT+} & I+) or (CX- & {@MV+}) 
or [[()]]));
ought.v: (({Q-} & (SI+ or SFI+)) or
({@E-} & (S- or SF- or (RS- & B-)))) & (TO+ or (N+ & I+));
won't can't mustn't couldn't shouldn't cannot needn't: 
({Q-} & (SI+ or SFI+) & I+) or
({@E-} & (S- or SF- or (RS- & B-)) & (I+ or [[()]]));
wouldn't: ({Q-} & (SI+ or SFI+) & {RT+} & I+) or
({@E-} & (S- or SF- or (RS- & B-)) & (({RT+} & I+) 
or [[()]]));

% COMMON VERB CATEGORIES (The last number of the file name indicates
% the verb form: 1=plural-infinitive, 2=singular, 3=past("ed"), 
% 4=progressive("-ing"), 5=gerund("-ing".)

<vc-intrans>: {@MV+};
% common intransitive verbs
/en/words/words.v.1.1:  
<verb-pl,i> & <vc-intrans>;
/en/words/words.v.1.2:  
<verb-s> & <vc-intrans>;
/en/words/words.v.1.3:  
<verb-sp,pp> & <vc-intrans>;
/en/words/words.v.1.4:  
(<vc-intrans> & <verb-pg,ge>) or ({@E-} & A+) or <verb-ge-d>;
arisen.v: {@E-} & PP- & {@MV+};

<vc-walk>: {K+} & {@MV+}; 
% intransitive verbs that can take particles like "up" and "out"
/en/words/words.v.5.1: 
<verb-pl,i> & <vc-walk>;
/en/words/words.v.5.2:
<verb-s> & <vc-walk>;
/en/words/words.v.5.3:
<verb-sp,pp> & <vc-walk>;
come.v: (<verb-pl,i> or <verb-pp>) & <vc-walk>;
swam.v lay.x came.v: <verb-sp> & <vc-walk>; 
swum.v lain.v: <verb-pp> & <vc-walk>;
/en/words/words.v.5.4: (<vc-walk> & <verb-pg,ge>) or ({@E-} & A+)
or <verb-ge-d>;

<vc-tr,intr>: {O+ or B- or [[@MV+ & O*n+]]} & {@MV+};
% optionally transitive verbs
/en/words/words.v.2.1:
<verb-pl,i> & <vc-tr,intr>;
/en/words/words.v.2.2:  
<verb-s> & <vc-tr,intr>;
/en/words/words.v.2.3:  
(<verb-sp,pp> & <vc-tr,intr>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
shrank.v sang.v withdrew.v sank.v forgave.v:
<verb-sp> & <vc-tr,intr>;
shrunk.v sung.v withdrawn.v sunk.v forgiven.v:
(<verb-pp> & <vc-tr,intr>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
bid.v hurt.v thrust.v broadcast.v:
((<verb-pl,i> or <verb-sp,pp>) & <vc-tr,intr>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
/en/words/words.v.2.4:  
<verb-pg> & <vc-tr,intr>;
/en/words/words.v.2.5:  
(<vc-tr,intr> & <verb-ge>) or ({@E-} & A+) or <verb-ge-d>;

<vc-rise>: {K+ or OD+} & {@MV+};
rise.v fall.v: <verb-pl,i> & <vc-rise>;
rises.v falls.v: <verb-s> & <vc-rise>;
rose.v fell.v: <verb-sp> & <vc-rise>;
risen.v: <verb-pp> & <vc-rise>;
fallen.v: (<verb-pp> & <vc-rise>) or ({@E-} & A+);
rising.v falling.v: (<vc-rise> & <verb-pg,ge>) or ({@E-} & A+)
or <verb-ge-d>;

<vc-fill>: ((K+ & {[[@MV+]]} & O*n+) or ({O+ or B-} & {K+}) or
[[@MV+ & O*n+]]) & {@MV+};
% optionally transitive verbs that can take particles like "up" and "out"
/en/words/words.v.6.1: <verb-pl,i> & <vc-fill>; 
/en/words/words.v.6.2: <verb-s> & <vc-fill>;
/en/words/words.v.6.3:
(<verb-sp,pp> & <vc-fill>) or (<verb-pv-b> & {K+} & {@MV+}) or ({@E-} & A+)
or ({K+} & <verb-po>);
split.v spread.v beat.v fit.v shut.v cast.v: ((<verb-pl,i> or <verb-sp,pp>) & 
<vc-fill>) or (<verb-pv> & {K+}) or ({@E-} & A+) or ({K+} & <verb-po>);
ate.v broke.v flew.v drove.v woke.v ran.v rode.v rang.v hid.v froze.v drew.v sprang.v: 
<verb-sp> & <vc-fill>;
eaten.v broken.v flown.v driven.v woken.v beaten.v ridden.v rung.v hidden.v stricken.v
frozen.v drawn.v sprung.v: (<verb-pp> & <vc-fill>) or 
(<verb-pv> & {K+}) or ({@E-} & A+) or ({K+} & <verb-po>);
run.v: ((<verb-pl,i> or <verb-pp>) & <vc-fill>) or 
(<verb-pv> & {K+}) or ({@E-} & A+) or ({K+} & <verb-po>);
/en/words/words.v.6.4:
<verb-pg> & <vc-fill>;
/en/words/words.v.6.5:
(<vc-fill> & <verb-ge>) or <verb-ge-d> or ({@E-} & A+);

<vc-trans>: (O+ or B- or [[@MV+ & O*n+]]) & {@MV+};
% common transitive verbs
/en/words/words.v.4.1:  
<verb-pl,i> & <vc-trans>;
/en/words/words.v.4.2:  
<verb-s> & <vc-trans>;
/en/words/words.v.4.3:  
(<verb-sp,pp> & <vc-trans>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
forsook.v overrode.v overtook.v rewrote.v undid.v overran.v mistook.v underwrote.v: 
<verb-sp> & <vc-trans>;
hit.v misread.v shed.v rid.v overcome.v offset.v overrun.v upset.v undercut.v: 
((<verb-pl,i> or <verb-sp,pp>) & <vc-trans>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
forsaken.v overridden.v overtaken.v rewritten.v undone.v beset.v mistaken.v underwritten.v: 
(<verb-pp> & <vc-trans>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
/en/words/words.v.4.4:  
<verb-pg> & <vc-trans>;
/en/words/words.v.4.5: 
(<vc-trans> & <verb-ge>) or <verb-ge-d>;

<vc-kick>: ((K+ & {[[@MV+]]} & O*n+) or ((O+ or B-) & {K+}) or 
[[@MV+ & O*n+]]) & {@MV+};
% transitive verbs that can take particles like "up" and "out"
/en/words/words.v.8.1: 
<verb-pl,i> & <vc-kick>;
/en/words/words.v.8.2:
<verb-s> & <vc-kick>;
bit.v threw.v stole.v drank.v shook.v wore.v blew.v tore.v: 
<verb-sp> & <vc-kick>;
bitten.v thrown.v stolen.v shaken.v worn.v blown.v torn.v:
(<verb-pp> & <vc-kick>) or (<verb-pv-b> & {K+} & {@MV+}) or ({@E-} & A+)
or ({K+} & <verb-po>);
/en/words/words.v.8.3:
(<verb-sp,pp> & <vc-kick>) or (<verb-pv-b> & {K+} & {@MV+}) or ({@E-} & A+)
or ({K+} & <verb-po>);
cut.v: ((<verb-pl,i> or <verb-sp,pp>) & <vc-kick>) or
(<verb-pv-b> & {K+} & {@MV+}) or ({@E-} & A+) or ({K+} & <verb-po>);
/en/words/words.v.8.4: <verb-pg> & <vc-kick>;
/en/words/words.v.8.5:
(<vc-kick> & <verb-ge>) or <verb-ge-d>;

<vc-raise>: (((O+ or B-) & {OD+}) or [[@MV+ & O*n+]]) & {@MV+};
raise.v lower.v: <verb-pl,i> & <vc-raise>;
raises.v lowers.v: <verb-s> & <vc-raise>;
raised.v lowered.v: (<verb-sp,pp> & <vc-raise>) or <verb-pv> or ({@E-} & A+)
 or <verb-po>;
raising.v lowering.v: <verb-pg> & <vc-raise>;
raising.g lowering.g: (<vc-raise> & <verb-ge>) or <verb-ge-d>;

% INTRANSITIVE COMPLEX VERBS (those that do not take O+)

<vc-consent>: {@MV+} & {TO+};
consent.v hesitate.v proceed.v aspire.v purport.v: <verb-pl,i> & 
<vc-consent>;
consents.v hesitates.v proceeds.v aspires.v purports.v: <verb-s> & 
<vc-consent>;
consented.v hesitated.v proceeded.v aspired.v purported.v: <verb-sp,pp> &
<vc-consent>;
consenting.v hesitating.v proceeding.v aspiring.v purporting.v:
(<vc-consent> & <verb-pg,ge>) or <verb-ge-d>;

<vc-deign>: {@MV+} & TO+;
endeavour.v condescend.v deign.v: <verb-pl,i> & <vc-deign>;
endeavours.v condescends.v deigns.v: <verb-s> & <vc-deign>;
endeavoured.v condescended.v deigned.v: <verb-sp,pp> & <vc-deign>;
endeavouring.v condescending.v deigning.v: (<vc-deign> & <verb-pg,ge>) or 
<verb-ge-d>;

<vc-happen>: {@MV+} & {TO+ or THi+};
happen.v: <verb-pl,i> & <vc-happen>;
happens.v: <verb-s> & <vc-happen>;
happened.v: <verb-sp,pp> & <vc-happen>;
happening.v: (<vc-happen> & <verb-pg,ge>) or <verb-ge-d>;

<vc-wish>: {@MV+} & {TH+ or Ce+ or RSe+ or TO+};
wish.v hope.v agree.v pretend.v swear.v pray.v vow.v vote.v: <verb-pl,i> & <vc-wish>;
wishes.v hopes.v agrees.v pretends.v swears.v prays.v vows.v votes.v: 
<verb-s> & <vc-wish>;
wished.v pretended.v prayed.v vowed.v: <verb-sp,pp> & <vc-wish>;
hoped.v voted.v: (<verb-sp,pp> & <vc-wish>) or (<verb-s-pv> & THi+);
agreed.v: (<verb-sp,pp> & <vc-wish>) or (<verb-pv> & TH+);
swore.v: <verb-sp> & <vc-wish>;
sworn.v: (<verb-pp> & <vc-wish>) or ({@E-} & A+);
wishing.v hoping.v agreeing.v pretending.v swearing.v praying.v vowing.v voting.v: 
(<vc-wish> & <verb-pg,ge>) or <verb-ge-d>;

<vc-appear>: {@MV+} & {Pa+ or TOf+ or THi+ or AF- or [[Pv+]]};
appear.v: <verb-x-pl,i> & <vc-appear>;
appears.v: <verb-x-s> & <vc-appear>;
appeared.v: <verb-x-sp,pp> & <vc-appear>;
appearing.v: (<vc-appear> & <verb-x-pg,ge>) or <verb-ge-d>;

<vc-seem>: {@MV+} & (Pa+ or TOf+ or LI+ or THi+ or AF- or [[Pv+]]);
seem.v: <verb-x-pl,i> & <vc-seem>;
seems.v: <verb-x-s> & <vc-seem>;
seemed.v: <verb-x-sp,pp> & <vc-seem>;
seeming.v: (<vc-seem> & <verb-x-pg,ge>) or <verb-ge-d>;

<vc-care>: {@MV+} & {TO+ or QI+};
care.v: <verb-pl,i> & <vc-care>;
cares.v: <verb-s> & <vc-care>;
cared.v: <verb-sp,pp> & <vc-care>;
caring.v: (<vc-care> & <verb-pg,ge>) or <verb-ge-d>;

<vc-assert>: ({@MV+} & (TH+ or RSe+ or Z- or Ce+));
assert.v contend.v remark.v retort.v intimate.v exclaim.v 
conjecture.v allege.v surmise.v opine.v insinuate.v suppose.v: 
<verb-pl,i> & <vc-assert>; 
asserts.v contends.v remarks.v retorts.v intimates.v exclaims.v
conjectures.v alleges.v surmises.v opines.v insinuates.v supposes.v: 
<verb-s> & <vc-assert>;
retorted.v intimated.v exclaimed.v conjectured.v
surmised.v opined.v insinuated.v: <verb-sp,pp> & <vc-assert>;
asserted.v contended.v remarked.v: (<verb-sp,pp> & <vc-assert>) or
(<verb-pv> & THi+);
alleged.v: (<verb-sp,pp> & <vc-assert>) or (<verb-pv> & THi+) 
or ({@E-} & A+);
supposed.v: (<verb-sp,pp> & <vc-assert>) or (<verb-s-pv> & 
{TOf+ or THi+ or Z-}) or ({@E-} & A+);
asserting.v contending.v remarking.v retorting.v intimating.v
exclaiming.v conjecturing.v alleging.v surmising.v opining.v insinuating.v
supposing.v: 
(<vc-assert> & <verb-pg,ge>) or <verb-ge-d>;

<vc-muse>: {@MV+} & {TH+};
theorize.v attest.v fantasize.v muse.v speculate.v concur.v:
 <verb-pl,i> & <vc-muse>;
theorizes.v attests.v fantasizes.v muses.v speculates.v concurs.v:
 <verb-s> & <vc-muse>;
attested.v fantasized.v mused.v speculated.v concurred.v: 
<verb-sp,pp> & <vc-muse>;
theorized.v:  (<verb-sp,pp> & <vc-muse>) or (<verb-pv> & THi+);
theorizing.v attesting.v fantasizing.v musing.v speculating.v concurring.v: 
(<vc-muse> & <verb-pg,ge>) or <verb-ge-d>;

<vc-reply>: ({@MV+} & {TH+ or Ce+});
reply.v shout.v whisper.v argue.v sigh.v mutter.v 
testify.v comment.v respond.v hint.v reason.v brag.v:
<verb-pl,i> & <vc-reply>;
replies.v shouts.v whispers.v argues.v sighs.v 
mutters.v testifies.v comments.v responds.v hints.v reasons.v 
brags.v:
<verb-s> & <vc-reply>;
replied.v shouted.v whispered.v argued.v sighed.v 
muttered.v testified.v commented.v responded.v hinted.v reasoned.v 
bragged.v:
<verb-sp,pp> & <vc-reply>;
replying.v shouting.v whispering.v arguing.v sighing.v
muttering.v testifying.v commenting.v responding.v hinting.v 
reasoning.v bragging.v:
(<vc-reply> & <verb-pg,ge>) or <verb-ge-d>;

<vc-dream>: {@MV+} & {Ce+ or TH+ or RSe+ or (OF+ & {@MV+}) or BW-};
dream.v complain.v: <verb-pl,i> & <vc-dream>;
dreams.v complains.v: <verb-s> & <vc-dream>;
dreamt dreamed complained.v: <verb-sp,pp> & <vc-dream>;
dreaming.g complaining.g: (<vc-dream> & <verb-ge>) or <verb-ge-d>;
dreaming.v complaining.v: <verb-pg> & <vc-dream>;

<vc-think>: {@MV+} & {Ce+ or TH+ or RSe+ or Z- or (OF+ & {@MV+}) or BW-};
think.v: <verb-pl,i> & <vc-think>;
thinks.v: <verb-s> & <vc-think>;
thought.v: (<verb-sp,pp> & <vc-think>) or (<verb-s-pv> & {THi+ or Z-});
thinking.g: (<vc-think> & <verb-ge>) or <verb-ge-d>;
thinking.v: <verb-pg> & <vc-think>;

<vc-matter>: {@MV+} & {THi+ or QIi+};
matter.v: <verb-s-pl,i> & <vc-matter>;
matters.v: <verb-s-s> & <vc-matter>;
mattered.v: <verb-sp,pp> & <vc-matter>;
mattering.v: (<vc-matter> & <verb-pg,ge>) or <verb-ge-d>;

<vc-suffice>: {@MV+} & {THi+};
suffice.v: <verb-pl,i> & <vc-suffice>;
suffices.v: <verb-s> & <vc-suffice>;
sufficed.v: <verb-sp,pp> & <vc-suffice>;
sufficing.v: (<vc-suffice> & <verb-pg,ge>) or <verb-ge-d>;

<vc-insist>: ({@MV+} & {TH+ or Zs- or TS+ or Ce+}) or (SI*j+ & I*j+);
insist.v: <verb-pl,i> & <vc-insist>;
insists.v: <verb-s> & <vc-insist>;
insisted.v: <verb-sp,pp> & <vc-insist>;
insisting.v: (<vc-insist> & <verb-pg,ge>) or <verb-ge-d>;

<vc-wonder>: {@MV+} & {QI+};
wonder.v inquire.v: <verb-pl,i> & <vc-wonder>;
wonders.v inquires.v: <verb-s> & <vc-wonder>;
wondered.v inquired.v: <verb-sp,pp> & <vc-wonder>;
wondering.v inquiring.v: (<vc-wonder> & <verb-pg,ge>) or <verb-ge-d>;

<vc-go>: {K+ or [[Pa+]] or [[Pg+]]} & {@MV+}; 
go.v: <verb-pl,i> & <vc-go>;
goes.v: <verb-s> & <vc-go>;
went.v: <verb-sp> & <vc-go>; 
gone.v: <verb-pp> & <vc-go>;
going.v: ((TOf+ or ({K+ or [[Pa+]]} & {@MV+})) & <verb-x-pg,ge>) or ({@E-} & A+) or
<verb-ge-d>;

<vc-stay>: {({@MV+} & (Pa+ or AF-)) or ({K+} & {@MV+})};
stay.v: <verb-pl,i> & <vc-stay>;
stays.v: <verb-s> & <vc-stay>;
stayed.v: <verb-sp,pp> & <vc-stay>;
staying.v: (<vc-stay> & <verb-pg,ge>) or <verb-ge-d>;

<vc-act>: {@MV+} & {LI+ or Pa+ or AF-};
act.v sound.v: <verb-pl,i> & <vc-act>;
acts.v sounds.v: <verb-s> & <vc-act>;
acted.v sounded.v: <verb-sp,pp> & <vc-act>;
acting.v sounding.v: (<vc-act> & <verb-pg,ge>) or <verb-ge-d>;

<vc-look>: {({@MV+} & (LI+ or Pa+)) or ({K+ or AF-} & {@MV+})};
look.v: <verb-pl,i> & <vc-look>;
looks.v: <verb-s> & <vc-look>;
looked.v: <verb-sp,pp> & <vc-look>;
looking.v: (<vc-look> & <verb-pg,ge>) or <verb-ge-d>;

<vc-repent>: {OF+} & {@MV+};
repent.v disapprove.v talk.v: <verb-pl,i> & <vc-repent>;
repents.v disapproves.v talks.v: <verb-s> & <vc-repent>;
repented.v disapproved.v talked.v: <verb-sp,pp> & <vc-repent>;
repenting.v disapproving.v talking.v: 
(<vc-repent> & <verb-pg,ge>) or <verb-ge-d>;

<vc-consist>: OF+ & {@MV+};
consist.v: <verb-pl,i> & <vc-consist>;
consists.v: <verb-s> & <vc-consist>;
consisted.v: <verb-sp,pp> & <vc-consist>; 
consisting.v: (<vc-consist> & <verb-pg,ge>) or <verb-ge-d>;

<vc-die>: {K+ or OF+} & {@MV+};
die.v: <verb-pl,i> & <vc-die>;
dies.v: <verb-s> & <vc-die>;
died.v: <verb-sp,pp> & <vc-die>;
dying.v: (<vc-die> & <verb-pg,ge>) or <verb-ge-d>;

<vc-last>: {({[[@MV+]]} & OT+) or BT-} & {@MV+};
last.v wait.v: <verb-pl,i> & <vc-last>;
lasts.v waits.v: <verb-s> & <vc-last>;
lasted.v waited.v: <verb-sp,pp> & <vc-last>;
lasting.v waiting.v: <verb-pg> & <vc-last>;
lasting.g waiting.g: (<vc-last> & <verb-ge>) or <verb-ge-d>;

% TRANSITIVE COMPLEX VERBS (Those that take O+)

<vc-attempt>: ({@MV+} & TO+) or ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+});
attempt.v undertake.v deserve.v manage.v plot.v prefer.v neglect.v
afford.v commit.v profess.v desire.v:
<verb-pl,i> & <vc-attempt>;
attempts.v undertakes.v deserves.v manages.v plots.v prefers.v
neglects.v affords.v commits.v professes.v desires.v:
<verb-s> & <vc-attempt>;
attempted.v deserved.v managed.v plotted.v preferred.v neglected.v afforded.v committed.v
professed.v desired.v:
(<verb-sp,pp> & <vc-attempt>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
undertook.v: <verb-sp> & <vc-attempt>;
undertaken.v: (<verb-pp> & <vc-attempt>) or <verb-pv>;
attempting.g undertaking.g deserving.g  
plotting.g preferring.g neglecting.g affording.g committing.g professing.g
desiring.g:
(<vc-attempt> & <verb-ge>) or <verb-ge-d>;
managing.g: (<vc-attempt> & <verb-ge>) or <verb-ge-d> or ({@E-} & A+);
attempting.v undertaking.v deserving.v managing.v
plotting.v preferring.v neglecting.v affording.v committing.v professing.v
desiring.v:
<verb-pg> & <vc-attempt>; 

<vc-seek>: ({@MV+} & TO+) or 
((((O+ or B-) & {K+}) or (K+ & {[[@MV+]]} & O*n+) or 
([[@MV+ & O*n+]])) & {@MV+});
seek.v: <verb-pl,i> & <vc-seek>;
seeks.v: <verb-s> & <vc-seek>;
sought.v: (<verb-sp,pp> & <vc-seek>) or <verb-pv> or <verb-po>;
seeking.g: (<vc-seek> & <verb-ge>) or <verb-ge-d>;
seeking.v: <verb-pg> & <vc-seek>;

<vc-decline>: ({@MV+} & TO+) or ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+});
decline.v fail.v hasten.v volunteer.v aim.v: <verb-pl,i> & <vc-decline>;
declines.v fails.v hastens.v volunteers.v aims.v: <verb-s> & <vc-decline>;
declined.v hastened.v volunteered.v aimed.v: (<verb-sp,pp> & <vc-decline>) or 
<verb-pv> or <verb-po>;
failed.v: (<verb-sp,pp> & <vc-decline>) or <verb-pv> or ({@E-} & A+);
declining.g failing.g hastening.g volunteering.g: 
(<vc-decline> & <verb-ge>) or <verb-ge-d>
or ({@E-} & A+);
declining.v failing.v hastening.v volunteering.v aiming.v: 
<verb-pg> & <vc-decline>;

<vc-fight>: ({@MV+} & TO+) or 
({({O+ or B-} & {K+}) or (K+ & {[[@MV+]]} & O*n+) or 
[[@MV+ & O*n+]]} & {@MV+});
fight.v: <verb-pl,i> & <vc-fight>;
fights.v: <verb-s> & <vc-fight>;
fought.v: (<verb-sp,pp> & <vc-fight>) or (<verb-pv-b> & {K+} & {@MV+}) or
({K+} & <verb-po>);
fighting.g: (<vc-fight> & <verb-ge>) or <verb-ge-d>;
fighting.v: <verb-pg> & <vc-fight>;

<vc-threaten>: ({@MV+} & (TO+ or TH+ or Zs- or Ce+)) or 
((O+ or B- or [[@MV+ & O*n+]]) & {@MV+});
threaten.v mean.v arrange.v resolve.v pledge.v:
<verb-pl,i> & <vc-threaten>;
threatens.v means.v arranges.v resolves.v pledges.v:
<verb-s> & <vc-threaten>;
threatened.v meant.v arranged.v resolved.v pledged.v:
(<verb-sp,pp> & <vc-threaten>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
meaning.g arranging.g resolving.g threatening.g pledging.g: 
(<vc-threaten> & <verb-ge>) or <verb-ge-d>;
meaning.v arranging.v resolving.v threatening.v pledging.v:
<verb-pg> & <vc-threaten>;

<vc-plan>: ({@MV+} & {TO+ or TH+ or Zs- or Ce+}) or 
((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}); 
plan.v confess.v: <verb-pl,i> & <vc-plan>;
plans.v confesses.v: <verb-s> & <vc-plan>;
planned.v confessed.v: (<verb-sp,pp> & <vc-plan>) or <verb-pv> or 
({@E-} & A+) or <verb-po>;
planning.g confessing.g: (<vc-plan> & <verb-ge>) or <verb-ge-d>;
planning.v confessing.v: <verb-pg> & <vc-plan>;

<vc-decide>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or
({@MV+} & {QI+ or TO+ or Ce+ or TH+ or RSe+ or Zs-});
decide.v: <verb-pl,i> & <vc-decide>;
decides.v: <verb-s> & <vc-decide>;
decided.v: (<verb-sp,pp> & <vc-decide>) or (<verb-s-pv> & {THi+}) 
or <verb-po>;
deciding.v: <verb-pg> & <vc-decide>;
deciding.g: (<vc-decide> & <verb-ge>) or <verb-ge-d>;

<vc-forget>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or  
({@MV+} & (TH+ or TO+ or Ce+ or RSe+ or Zs- or QI+
or Pg+));					
remember.v forget.v: <verb-pl,i> & <vc-forget>;
remembers.v forgets.v: <verb-s> & <vc-forget>;
remembered.v: (<verb-sp,pp> & <vc-forget>) or <verb-pv> or <verb-po>;
forgot.v: <verb-sp> & <vc-forget>;
forgotten.v: (<verb-pp> & <vc-forget>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
remembering.g forgetting.g: (<vc-forget> & <verb-ge>) or <verb-ge-d>;
remembering.v forgetting.v: <verb-pg> & <vc-forget>;

<vc-learn>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or 
({@MV+} & (TH+ or TO+ or Ce+ or RSe+ or Zs- or QI+ or (OF+ & {@MV+})));
learn.v: <verb-pl,i> & <vc-learn>;
learns.v: <verb-s> & <vc-learn>;
learned.v: (<verb-sp,pp> & <vc-learn>) or (<verb-pv> & {THi+}) or <verb-po>;
learning.g: (<vc-learn> & <verb-ge>) or <verb-ge-d>;
learning.v: <verb-pg> & <vc-learn>;

<vc-propose>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or
({@MV+} & (TO+ or TH+ or Ce+ or RSe+ or Z- or Pg+ or TS+ or (SI*j+ & I*j+)));
propose.v: <verb-pl,i> & <vc-propose>;
proposes.v: <verb-s> & <vc-propose>;
proposed.v: (<verb-sp,pp> & <vc-propose>) or 
(<verb-s-pv> & {THi+ or TSi+ or Z-}) or ({@E-} & A+) or <verb-po>;
proposing.g: (<vc-propose> & <verb-ge>) or <verb-ge-d>;
proposing.v: <verb-pg> & <vc-propose>;

<vc-demand>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or
({@MV+} & ((TO+ or TH+ or Z- or TS+ or ((SI*j+ or SFI**j+) & I*j+))));
demand.v: <verb-pl,i> & <vc-demand>;
demands.v: <verb-s> & <vc-demand>;
demanded.v: (<verb-sp,pp> & <vc-demand>) or <verb-pv> or 
<verb-po>;
demanding.v: <verb-pg> & <vc-demand>;
demanding.g: (<vc-demand> & <verb-ge>) or <verb-ge-d>;

<vc-beg>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or
({@MV+} & ((TO+ or TH+ or Z- or TS+ or ((SI*j+ or SFI**j+) & I*j+))));
beg.v plead.v: <verb-pl,i> & <vc-beg>;
begs.v pleads.v: <verb-s> & <vc-beg>;
begged.v pleaded.v: (<verb-sp,pp> & <vc-beg>) or <verb-pv> or 
<verb-po>;
begging.v pleading.v: <verb-pg> & <vc-beg>;
begging.g pleading.g: (<vc-beg> & <verb-ge>) or <verb-ge-d>;

<vc-bear>: (O+ or B- or [[@MV+ & O*n+]]) & {@MV+};
bear.v: (<verb-i> & (<vc-bear> or
({@MV+} & (Pg+ or TH+ or TO+)))) or (<verb-pl> & <vc-bear>);
bears.v: <verb-s> & <vc-bear>;
bore.p: <verb-sp,pp> & <vc-bear>;
born.v: (<verb-pp> & <vc-bear>) or <verb-pv> or <verb-po>;
bearing.g: (<vc-bear> & <verb-ge>) or <verb-ge-d>;
bearing.v: <verb-pg> & <vc-bear>;

<vc-love>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or 
({@MV+} & (TO+ or Pg+));
love.v dislike.v hate.v: <verb-pl,i> & <vc-love>;
loves dislikes.v hates.v: <verb-s> & <vc-love>;
loved disliked.v hated.v: (<verb-sp,pp> & <vc-love>) or <verb-pv> or <verb-po>;
loving.g disliking.g hating.g: (<vc-love> & <verb-ge>) or <verb-ge-d>;
loving.v disliking.v hating.v: <verb-pg> & <vc-love>;

<vc-begin>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or
 ({@MV+} & (TO+ or Pg+));
begin.v continue.v cease.v: <verb-pl,i> & <vc-begin>;
begins.v continues.v ceases.v: <verb-s> & <vc-begin>;
ceased.v: (<verb-sp,pp> & <vc-begin>) or <verb-pv> or <verb-po>;
continued.v: (<verb-sp,pp> & <vc-begin>) or <verb-pv> or <verb-po>
or ({@E-} & A+);
began.v: <verb-sp> & <vc-begin>;
begun.v: (<verb-pp> & <vc-begin>) or <verb-pv> or <verb-po>;
beginning.g ceasing.g: 
(<vc-begin> & <verb-ge>) or <verb-ge-d>;
continuing.g: (<vc-begin> & <verb-ge>) or <verb-ge-d> or ({@E-} & A+);
beginning.v continuing.v ceasing.v: <verb-pg> & <vc-begin>;

<vc-start>: ((({O+ or B-} & {K+}) or (K+ & {[[@MV+]]} & O*n+)
or [[@MV+ & O*n+]]) & {@MV+}) or ({@MV+} & (TO+ or Pg+));
start.v stop.v try.v: <verb-pl,i> & <vc-start>;
starts.v stops.v tries.v: <verb-s> & <vc-start>;
started.v stopped.v tried.v: (<verb-sp,pp> & <vc-start>) or (<verb-pv-b> 
& {K+} & {@MV+}) or ({K+} & <verb-po>);
starting.g stopping.g trying.g: (<vc-start> & <verb-ge>) or <verb-ge-d>;
starting.v stopping.v trying.v: <verb-pg> & <vc-start>;

<vc-dispute>: ({@MV+} & (TH+ or Zs-)) or ((O+ or B- or [[@MV+ & O*n+]]) 
& {@MV+});
recognize.v dispute.v accept.v calculate.v
record.v deduce.v envision.v recount.v signify.v clarify.v disclose.v 
recollect.v adduce.v posit.v reiterate.v infer.v presuppose.v: 
<verb-pl,i> & <vc-dispute>;
recognizes.v disputes.v calculates.v records.v deduces.v
accepts.v envisions.v recounts.v signifies.v clarifies.v discloses.v recollects.v
adduces.v posits.v reiterates.v infers.v presupposes.v: 
<verb-s> & <vc-dispute>;
recognized.v disputed.v accepted.v calculated.v recorded.v deduced.v envisioned.v
recounted.v signified.v clarified.v disclosed.v recollected.v adduced.v posited.v
reiterated.v inferred.v presupposed.v:
 (<verb-sp,pp> & <vc-dispute>) or (<verb-s-pv> & {THi+}) or ({@E-} & A+)
or <verb-po>; 
recognizing.g disputing.g accepting.g calculating.g deducing.g recording.g 
envisioning.g recounting.g signifying.g clarifying.g disclosing.g
recollecting.g adducing.g positing.g reiterating.g inferring.g presupposing.g:
(<vc-dispute> & <verb-ge>) or <verb-ge-d>;
recognizing.v disputing.v accepting.v calculating.v deducing.v recording.v
envisioning.v recounting.v signifying.v clarifying.v disclosing.v
recollecting.v adducing.v positing.v reiterating.v inferring.v presupposing.v:
<verb-pg> & <vc-dispute>;

<vc-repeat>: ({@MV+} & TH+) or ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+});
repeat.v reflect.v provide.v counter.v signal.v: <verb-pl,i> & <vc-repeat>;
repeats.v reflects.v provides.v counters.v signals.v: <verb-s> & <vc-repeat>;
repeated.v reflected.v countered.v signaled.v signalled.v: 
(<verb-sp,pp> & <vc-repeat>) or <verb-pv> or <verb-po> or ({@E-} & A+);
provided.v: (<verb-sp,pp> & <vc-repeat>) or <verb-pv> or <verb-po> or ({@E-} &
 A+) or
((TH+ or Ce+) & (({{Xd-} & Xc+} & CO+) or ({Xd- & Xc+} & MVs-)));
repeating.v reflecting.v providing.v countering.v signaling.v signalling.v: 
<verb-pg> & <vc-repeat>;
repeating.g reflecting.g countering.g signaling.g signalling.g: 
(<vc-repeat> & <verb-ge>) or <verb-ge-d>;
providing.g: (<vc-repeat> & <verb-ge>) or <verb-ge-d>
or ((TH+ or Ce+) & (({{Xd-} & Xc+} & CO+) or ({Xd- & Xc+} & MVs-)));

<vc-sense>: ({@MV+} & (Ce+ or TH+ or RSe+)) or ((O+ or B- or [[@MV+ & O*n+]])
 & {@MV+});
sense.v doubt.v reaffirm.v reckon.v regret.v proclaim.v ascertain.v discern.v 
stipulate.v affirm.v certify.v trust.v postulate.v ensure.v imply.v verify.v boast.v:
 <verb-pl,i> & <vc-sense>;
senses.v reaffirms.v doubts.v reckons.v regrets.v proclaims.v 
stipulates.v ascertains.v discerns.v affirms.v certifies.v trusts.v 
postulates.v ensures.v implies.v verifies.v boasts.v: 
<verb-s> & <vc-sense>;
doubted.v reaffirmed.v sensed.v reckoned.v regretted.v stipulated.v
proclaimed.v ascertained.v discerned.v affirmed.v certified.v 
trusted.v postulated.v ensured.v implied.v verified.v boasted.v:
(<verb-sp,pp> & <vc-sense>) or (<verb-s-pv> & {THi+}) or ({@E-} & A+)
or <verb-po>;
reaffirming.g sensing.g doubting.g stipulating.g
reckoning.g regretting.g proclaiming.g ascertaining.g 
discerning.g affirming.g certifying.g trusting.g 
postulating.g ensuring.g implying.g verifying.g boasting.g:
 (<vc-sense> & <verb-ge>) or <verb-ge-d>;
sensing.v doubting.v reckoning.v reaffirming.v stipulating.v
regretting.v proclaiming.v ascertaining.v discerning.v 
affirming.v certifying.v trusting.v postulating.v ensuring.v 
implying.v verifying.v boasting.v:
 <verb-pg> & <vc-sense>;

<vc-declare>: ({@MV+} & (Ce+ or TH+ or RSe+ or Z-)) or ((O+ or B- or
[[@MV+ & O*n+]]) & {@MV+});
declare.v imagine.v fear.v conclude.v suspect.v concede.v presume.v foresee.v
emphasize.v maintain.v acknowledge.v note.v confirm.v stress.v assume.v: 
<verb-pl,i> & <vc-declare>;
declares.v imagines.v fears.v concludes.v 
suspects.v concedes.v presumes.v foresees.v
emphasizes.v maintains.v acknowledges.v notes.v
confirms.v stresses.v assumes.v: 
<verb-s> & <vc-declare>;
declared.v imagined.v feared.v concluded.v suspected.v conceded.v presumed.v
emphasized.v maintained.v acknowledged.v noted.v 
confirmed.v stressed.v assumed.v: 
(<verb-sp,pp> & <vc-declare>) or (<verb-s-pv> & {THi+}) or ({@E-} & A+)
or <verb-po>;
foresaw.v: <verb-sp> & <vc-declare>;
foreseen.v: (<verb-pp> & <vc-declare>) or (<verb-s-pv> & {@MV+ or THi+}) or 
({@E-} & A+) or <verb-po>;
declaring.g imagining.g fearing.g 
concluding.g suspecting.g conceding.g
presuming.g foreseeing.g emphasizing.g maintaining.g acknowledging.g noting.g
confirming.g stressing.g
assuming.g: (<vc-declare> & <verb-ge>) or <verb-ge-d>;
declaring.v imagining.v fearing.v
concluding.v suspecting.v conceding.v
presuming.v foreseeing.v
emphasizing.v maintaining.v acknowledging.v
noting.v confirming.v stressing.v 
assuming.v: <verb-pg> & <vc-declare>;

<vc-believe>: ({@MV+} & (Ce+ or TH+ or RSe+)) or ({O+ or B- or 
[[@MV+ & O*n+]]} & {@MV+});
believe.v answer.v worry.v protest.v: <verb-pl,i> & <vc-believe>;
believes.v answers.v worries.v protests.v: <verb-s> & <vc-believe>;
believed.v answered.v worried.v protested.v: 
(<verb-sp,pp> & <vc-believe>) or (<verb-s-pv> & {THi+ or TOf+}) or <verb-po>;
believing.g answering.g worrying.g protesting.g: 
(<vc-believe> & <verb-ge>) or <verb-ge-d>;
believing.v answering.v worrying.v protesting.v: <verb-pg> & <vc-believe>;

<vc-rule>: ({@MV+} & (Ce+ or TH+ or RSe+)) or 
((({O+ or B-} & {K+}) or (K+ & {[[@MV+]]} & O*n+)
or [[@MV+ & O*n+]]) & {@MV+});
rule.v add.v: <verb-pl,i> & <vc-rule>;
rules.v adds.v: <verb-s> & <vc-rule>;
ruled.v: 
(<verb-sp,pp> & <vc-rule>) or (<verb-s-pv-b> & {({@MV+} & (THi+ or TOf+)) or
({K+} & {@MV+})}) or ({K+} & <verb-po>);
added.v: 
(<verb-sp,pp> & <vc-rule>) or (<verb-s-pv-b> & {({@MV+} & (THi+ or TOf+)) or
({K+} & {@MV+})}) or ({K+} & <verb-po>) or ({@E-} & A+);
ruling.g adding.g: (<vc-rule> & <verb-ge>) or <verb-ge-d>;
ruling.v adding.v: <verb-pg> & <vc-rule>;

<vc-figure>: ({@MV+} & (TH+ or Zs- or Ce+)) or 
((((O+ or B-) & {K+}) or (K+ & {[[@MV+]]} & O*n+)) & {@MV+}) or 
([[@MV+ & O*n+]]);
figure.v: <verb-pl,i> & <vc-figure>;
figures.v: <verb-s> & <vc-figure>;
figured.v: (<verb-sp,pp> & <vc-figure>) or (<verb-pv-b> & {K+} & {@MV+})
or ({K+} & <verb-po>);
figuring.g: (<vc-figure> & <verb-ge>) or <verb-ge-d>;
figuring.v: <verb-pg> & <vc-figure>;

<vc-predict>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or
({@MV+} & (QI+ or Ce+ or TH+ or RSe+ or Zs-));
predict.v realize.v discover.v determine.v announce.v say.v mention.v admit.v
recall.v reveal.v state.v observe.v indicate.v: <verb-pl,i> & <vc-predict>;
predicts.v realizes.v discovers.v determines.v announces.v says.v 
mentions.v admits.v recalls.v reveals.v states.v observes.v indicates.v:
<verb-s> & <vc-predict>;
predicted.v realized.v discovered.v determined.v announced.v mentioned.v
admitted.v recalled.v revealed.v stated.v observed.v indicated.v:
(<verb-sp,pp> & <vc-predict>) or (<verb-s-pv> & {THi+}) or ({@E-} & A+)
or <verb-po>;
said.v: (<verb-sp,pp> & <vc-predict>) or ({@E-} & (Pvf- or [[Mv-]]) 
& {@MV+} & {THi+}) or [[{@E-} & A+]] or [[<verb-po>]];
predicting.g realizing.g discovering.g determining.g
announcing.g saying.g mentioning.g admitting.g recalling.g revealing.g
stating.g observing.g indicating.g: (<vc-predict> & <verb-ge>) or <verb-ge-d>;
predicting.v realizing.v discovering.v determining.v
announcing.v saying.v mentioning.v admitting.v recalling.v revealing.v
stating.v observing.v indicating.v: <verb-pg> & <vc-predict>;

<vc-guess>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) 
or ({@MV+} & (TH+ or QI+ or Ce+ or RSe+ or Zs-));
guess.v estimate.v understand.v notice.v explain.v demonstrate.v: 
<verb-pl,i> & <vc-guess>;
guesses.v estimates.v understands.v notices.v explains.v demonstrates.v:
<verb-s> & <vc-guess>;
guessed.v understood.v noticed.v explained.v demonstrated.v: 
(<verb-sp,pp> & <vc-guess>) or (<verb-s-pv> & {THi+}) or <verb-po>;
estimated.v: (<verb-sp,pp> & <vc-guess>) 
or (<verb-s-pv> & {THi+}) or <verb-po> or ({@E-} & A+);
guessing.g estimating.g understanding.g noticing.g explaining.g 
demonstrating.g: (<vc-guess> & <verb-ge>) or <verb-ge-d>;
guessing.v estimating.v understanding.v noticing.v explaining.v
demonstrating.v: <verb-pg> & <vc-guess>;

<vc-know>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) 
or ({@MV+} & ((OF+ & {@MV+}) or QI+ or Ce+ or TH+ or RSe+ or Zs-));
know.v: <verb-pl,i> & <vc-know>;
knows.v: <verb-s> & <vc-know>;
knew.v: <verb-sp> & <vc-know>;
known.v: (<verb-pp> & <vc-know>) or (<verb-s-pv> & {THi+ or TOf+ or QIi+})
or <verb-po> or ({@E-} & A+);
knowing.g: (<vc-know> & <verb-ge>) or <verb-ge-d>;
knowing.v: <verb-pg> & <vc-know>;

<vc-request>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or
({@MV+} & (TH+ or Ce+ or RSe+ or Zs- or TS+ or ((SI*j+ or SFI**j+) & I*j+)));
request.v: <verb-pl,i> & <vc-request>;
requests.v: <verb-s> & <vc-request>;
requested.v: (<verb-sp,pp> & <vc-request>) or (<verb-s-pv> & {THi+ or TSi+})
 or ({@E-} & A+) or <verb-po>;
requesting.g: (<vc-request> & <verb-ge>) or <verb-ge-d>;
requesting.v: <verb-pg> & <vc-request>;

<vc-feel>: 
((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or ({@MV+} & (Pa+ or TH+ or Ce+
 or RSe+ or AF- or Vf+ or (LI+ or {@MV+}) or [[Pv+]]));
feel.v: <verb-pl,i> & <vc-feel>;
feels.v: <verb-s> & <vc-feel>;
felt.v: (<verb-sp,pp> & <vc-feel>) or (<verb-s-pv> & {THi+}) or <verb-po>;
feeling.g: (<vc-feel> & <verb-ge>) or <verb-ge-d>;
feeling.v: <verb-pg> & <vc-feel>;

<vc-mind>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or 
({@MV+} & (QI+ or TH+ or Pg+));
mind.v: <verb-pl,i> & <vc-mind>;
minds.v: <verb-s> & <vc-mind>;
minded.v: (<verb-sp,pp> & <vc-mind>) or <verb-pv> or <verb-po>;
minding.g: (<vc-mind> & <verb-ge>) or <verb-ge-d>;
minding.v: <verb-pg> & <vc-mind>;

<vc-study>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or ({@MV+} & QI+);
study.v: <verb-pl,i> & <vc-study>;
studies.v: <verb-s> & <vc-study>;
studied.v: (<verb-sp,pp> & <vc-study>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
studying.g: (<vc-study> & <verb-ge>) or <verb-ge-d>;
studying.v: <verb-pg> & <vc-study>;

<vc-discuss>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or ({@MV+} & Pg+);
discuss.v oppose.v enjoy.v advocate.v contemplate.v entail.v necessitate.v
justify.v risk.v avoid.v involve.v anticipate.v favor.v: 
<verb-pl,i> & <vc-discuss>;
discusses.v opposes.v enjoys.v advocates.v contemplates.v entails.v necessitates.v
justifies.v risks.v avoids.v involves.v anticipates.v favors.v: 
<verb-s> & <vc-discuss>;
discussed.v opposed.v enjoyed.v advocated.v contemplated.v entailed.v
necessitated.v justified.v risked.v avoided.v involved.v anticipated.v favored.v: 
(<verb-sp,pp> & <vc-discuss>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
discussing.g opposing.g enjoying.g advocating.g contemplating.g
entailing.g necessitating.g justifying.g risking.g avoiding.g
anticipating.g favoring.g involving.g: 
(<vc-discuss> & <verb-ge>) or <verb-ge-d>;
discussing.v opposing.v enjoying.v advocating.v contemplating.v
entailing.v necessitating.v justifying.v risking.v avoiding.v involving.v
anticipating.v favoring.v: 
<verb-pg> & <vc-discuss>;

<vc-finish>: ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or ({@MV+} & Pg+);
finish.v practice.v resist.v: <verb-pl,i> & <vc-finish>;
finishes.v practices.v resists.v quits.v: <verb-s> & <vc-finish>;
finished.v practiced.v resisted.v quitted.v: 
(<verb-sp,pp> & <vc-finish>) or <verb-pv> or ({@E-} & A+) or <verb-po>;
quit.v: ((<verb-sp,pp> or <verb-pl,i>) & <vc-finish>) or <verb-pv> or 
({@E-} & A+) or <verb-po>;
finishing.g practicing.g resisting.g
quitting.g: (<vc-finish> & <verb-ge>) or <verb-ge-d>;
finishing.v practicing.v resisting.v quitting.v: <verb-pg> & <vc-finish>;

<vc-turn>: ((O+ or (K+ & {[[@MV+]]} & O*n+) or ({O+ or B-} & {K+}) or
 [[@MV+ & O*n+]]) & {@MV+}) or ({@MV+} & (Pa+ or AF-));
turn.v: <verb-pl,i> & <vc-turn>;
turns.v: <verb-s> & <vc-turn>;
turned.v: (<verb-sp,pp> & <vc-turn>) or (<verb-pv-b> & {K+} & {@MV+})
or ({K+} & <verb-po>);
turning.v: <verb-pg> & <vc-turn>;
turning.g: (<vc-turn> & <verb-ge>) or <verb-ge-d>;

<vc-become>: ((O+ or B- or TI+ or [[@MV+ & (O*n+ or TI+)]] or [[Pv+]]) 
& {@MV+}) or ({@MV+} & (AF- or Pa+));
become.v: ((<verb-s-pl,i> or <verb-s-pp>) & <vc-become>) or <verb-pv>;
becomes.v: <verb-s-s> & <vc-become>;
became.v: <verb-s-sp> & <vc-become>;
becoming.g: (<vc-become> & <verb-ge>) or <verb-ge-d>;
becoming.v: <verb-pg> & <vc-become>;

<vc-remain>: ({@MV+} & (AF- or Pa+)) or ({O+ or B- or TI+ or
[[@MV+ & (O*n+ or TI+)]] or [[Pv+]]} & {@MV+});
remain.v: <verb-pl,i> & <vc-remain>;
remains.v: <verb-s> & <vc-remain>;
remained.v: <verb-sp,pp> & <vc-remain>;
remaining.g: (<vc-remain> & <verb-ge>) or <verb-ge-d> or ({@E-} & A+);
remaining.v: <verb-pg> & <vc-remain>;

<vc-grow>: ({@MV+} & (AF- or Pa+)) or ((({O+ or B-} & {K+}) or 
(K+ & {[[@MV+]]} & O*n+) or [[@MV+ & O*n+]]) & {@MV+});
grow.v: <verb-pl,i> & <vc-grow>;
grows.v: <verb-s> & <vc-grow>;
grew.v: <verb-sp> & <vc-grow>;
grown.v: (<verb-pp> & <vc-grow>) or (<verb-pv-b> & {K+} & {@MV+}) or
({K+} & <verb-po>);
growing.g: (<vc-grow> & <verb-pg,ge>) or ({@E-} & A+) or <verb-ge-d>;
growing.v: <verb-pg> & <vc-grow>;

<vc-approve>: {O+ or B- or [[@MV+ & O*n+]] or ({@MV+} & OF+)} & {@MV+};
approve.v: <verb-pl,i> & <vc-approve>;
approves.v: <verb-s> & <vc-approve>;
approved.v: (<verb-sp,pp> & <vc-approve>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
approving.g: (<vc-approve> & <verb-ge>) or <verb-ge-d>;
approving.v: <verb-pg> & <vc-approve>;

<vc-dispose>: (O+ or B- or [[@MV+ & O*n+]] or ({@MV+} & OF+)) & {@MV+};
dispose.v conceive.v: <verb-pl,i> & <vc-dispose>;
disposes.v conceives.v: <verb-s> & <vc-dispose>;
disposed.v conceived.v: (<verb-sp,pp> & <vc-dispose>) or <verb-pv> or 
({@E-} & A+) or <verb-po>;
disposing.g conceiving.g: (<vc-dispose> & <verb-ge>) or <verb-ge-d>;
disposing.v conceiving.v: <verb-ge> & <vc-dispose>;

<vc-speak>: ((K+ & {[[@MV+]]} & O*n+) or ({O+ or B-} & {K+}) or 
[[@MV+ & O*n+]] or OF+) & {@MV+};
speak.v: <verb-pl,i> & <vc-speak>;
speaks.v: <verb-s> & <vc-speak>;
spoke.v: <verb-sp> & <vc-speak>;
spoken.v: (<verb-pp> & <vc-speak>) 
or (<verb-pv-b> & {K+} & {@MV+}) or ({K+} & <verb-po>) or ({@E-} & A+);
speaking.v: <verb-pg> & <vc-speak>;
speaking.g: (<vc-speak> & <verb-ge>) or <verb-ge-d> or ({@E-} & A+);

<vc-taste>: ({@MV+} & ((LI+ & {@MV+}) or AF- or Pa+ or OF+)) or 
((O+ or B- or [[@MV+ & O*n+]]) & {@MV+});
taste.v: <verb-pl,i> & <vc-taste>;
tastes.v: <verb-s> & <vc-taste>;
tasted.v: (<verb-sp,pp> & <vc-taste>) or <verb-pv> or <verb-po>;
tasting.g: (<vc-taste> & <verb-ge>) or <verb-ge-d>;
tasting.v: <verb-pg> & <vc-taste>;

<vc-smell>: ({@MV+} & ((LI+ & {@MV+}) or AF- or Pa+ or OF+)) or 
({O+ or B- or [[@MV+ & O*n+]]} & {@MV+});
smell.v: <verb-pl,i> & <vc-smell>;
smells.v: <verb-s> & <vc-smell>;
smelled.v: (<verb-sp,pp> & <vc-smell>) or <verb-pv> or <verb-po>;
smelling.g: (<vc-smell> & <verb-ge>) or <verb-ge-d>;
smelling.v: <verb-pg> & <vc-smell>;

<vc-take>: 
(((K+ & {[[@MV+]]} & O*n+) or ((O+ or B-) & {K+ or Vt+}) or [[@MV+ & O*n+]]) 
& {@MV+}) or 
({O+} & (OT+ or BT-) & {@MV+} & {(TOt+ & B+) or TOi+}) or 
(OXii+ & Vtg+ & {@MV+} & TH+);
take.v: <verb-s-pl,i> & <vc-take>;
takes.v: <verb-s-s> & <vc-take>;
took.v: <verb-s-sp> & <vc-take>;
taken.v: (<verb-s-pp> & <vc-take>) or (<verb-pv-b> & 
{K+} & {@MV+}) or ({@E-} & A+) or ({K+} & <verb-po>) or (Pvf- & Vtg+ & THi+);
taking.v: <verb-s-pg> & <vc-take>;
taking.g: (<vc-take> & <verb-ge>) or <verb-ge-d>;
for_granted: Vtg-;

% VERBS TAKING [OBJ] + [OTHER COMPLEMENT]

<vc-put>: ((K+ & {[[@MV+]]} & O*n+) or ((O+ or B-) & 
(K+ or Pp+ or WR-)) or (Vp+ & (Zs- or MVa+))) & {@MV+};
put.v: ((<verb-pl,i> or <verb-sp,pp>) & <vc-put>) or (<verb-pv-b> & 
(K+ or Pp+ or WR-) & {@MV+}) or ((K+ or Pp+) & <verb-po>);
puts.v: <verb-s> & <vc-put>;
putting.v: <verb-pg> & <vc-put>;
putting.g: (<vc-put> & <verb-ge>) or <verb-ge-d>;

<vc-cost>: (((O+ & {{[[@MV+]]} & O*n+}) or (B- & {O+})) & {@MV+} & {TOi+})
or ([[@MV+ & O*n+]]);
cost.v: (<verb-s-pl,i> or <verb-s-sp,pp>) & <vc-cost>;
costs.v: <verb-s-s> & <vc-cost>;
costing.v: <verb-s-pg> & <vc-cost>;
costing.g: (<vc-cost> & <verb-ge>) or <verb-ge-d>;

<vc-find>: ((K+ or O+) & {[[@MV+]]} & O*n+) or (B- & O+) or ((O+ or B-) & 
(({@MV+} & (Pa+ or AF- or Pg+)) or ({K+} & {@MV+}))) or ([[@MV+ & O*n+]]) or
({@MV+} & (TH+ or Ce+ or RSe+));
find.v: <verb-pl,i> & <vc-find>;
finds.v: <verb-s> & <vc-find>;
found.p: (<verb-sp,pp> & <vc-find>) or 
(<verb-pv-b> & (({K+ or AF-} & {@MV+}) or Pa+ or Pg+)) or 
({K+ or Pa+ or Pg+} & <verb-po>);
finding.v: <verb-pg> & <vc-find>;
finding.g: (<vc-find> & <verb-ge>) or <verb-ge-d>;

<vc-get>: ((O+ or B-) & (({K+} & {@MV+}) or ({@MV+} & (Pa+ or AF- or Pv+))))
or (((K+ & {[[@MV+]]} & O*n+) or K+ or (B- & O+) or (O+ & {[[@MV+]]} & O*n+))
 & {@MV+}) or ({@MV+} & (Pa+ or AF- or Pv+ or Pp+ or TO+));
get.v: <verb-pl,i> & <vc-get>;
gets.v: <verb-s> & <vc-get>;
got.v: <verb-sp,pp> & <vc-get>;
gotten.v: (<verb-pp> & <vc-get>) or (<verb-pv-b> & {K+ or Pp+} & {@MV+})
or ({K+ or Pp+} & <verb-po>);
getting.v: <verb-pg> & <vc-get>;
getting.g: (<vc-get> & <verb-ge>) or <verb-ge-d>;

<vc-leave>: ((O+ or B-) & 
(({K+} & {@MV+}) or ({@MV+} & {Pa+ or AF- or Pv+ or Pg+}))) or 
({(K+ & {[[@MV+]]} & O*n+) or ([[@MV+ & O*n+]])} & {@MV+});
leave.v: <verb-pl,i> & <vc-leave>;
leaves.v: <verb-s> & <vc-leave>;
left.v: (<verb-sp,pp> & <vc-leave>) or (<verb-pv-b> & 
(({K+ or AF-} & {@MV+}) or Pv+ or Pa+ or Pg+)) or 
({K+ or ({@MV+} & (Pv+ or Pa+ or Pg+))} & <verb-po>);
leaving.v: <verb-pg> & <vc-leave>;
leaving.g: (<vc-leave> & <verb-ge>) or <verb-ge-d>;

<vc-keep>: ((O+ or (K+ & {[[@MV+]]} & O*n+) or [[@MV+ & O*n+]] or Vk+) 
& {@MV+}) 
or ({O+ or B-} & ((K+ & {@MV+}) or ({@MV+} & (Pa+ or AF- or Pg+ or Pv+))));
keep.v: <verb-pl,i> & <vc-keep>;
keeps.v: <verb-s> & <vc-keep>;
kept.v: (<verb-sp,pp> & <vc-keep>) or 
(<verb-pv-b> & (({K+ or AF-} & {@MV+}) or Pa+ or Pg+ or Pv+)) or
({K+ or ({@MV+} & (Pa+ or Pg+ or Pv+))} & <verb-po>);
keeping.v: <verb-pg> & <vc-keep>;
keeping.g: (<vc-keep> & <verb-ge>) or <verb-ge-d>;

watch.i vigil.i pace.i: Vk-;
track.i: Vk- & {OF+};

<vc-set>: ((K+ & {[[@MV+]]} & O*n+) or ({O+ or B-} & {K+ or Vs+}) 
or [[@MV+ & O*n+]]) & {@MV+};
set.v: ((<verb-pl,i> or <verb-sp,pp>) & 
<vc-set>) or (<verb-pv> & {K+ or Vs+} & {@MV+}) or 
({@E-} & A+) or ({K+ or Vs+} & <verb-po>);
sets.v: <verb-s> & <vc-set>;
setting.v: <verb-pg> & <vc-set>;
setting.g: (<vc-set> & <verb-ge>) or <verb-ge-d> or ({@E-} & A+);

free.i straight.i loose.i: Vs- & {MV+};

<vc-hold>: ((K+ & {[[@MV+]]} & O*n+) or ({O+ or B-} & {K+ or Vh+}) or 
[[@MV+ & O*n+]]) & {@MV+};		
hold.v: <verb-pl,i> & <vc-hold>;
holds.v: <verb-s> & <vc-hold>;
held.v: (<verb-sp,pp> & <vc-hold>) or (<verb-pv-b> & {K+ or Vh+} & {@MV+}) or 
({@E-} & A+) or ({K+ or Vh+} & <verb-po>);
holding.v: <verb-pg> & <vc-hold>;
holding.g: (<vc-hold> & <verb-ge>) or <verb-ge-d>;

hostage.i captive.i: Vh- or Vth-;

<vc-expect>: ({@MV+} & (Ce+ or TH+ or RSe+ or Z- or TO+))
or ((O+ or OX+ or B-) & {@MV+} & {TOo+}) or ([[@MV+ & O*n+]]);
expect.v claim.v: <verb-pl,i> & <vc-expect>;
expects.v claims.v: <verb-s> & <vc-expect>;
expected.v claimed.v: (<verb-sp,pp> & <vc-expect>) or (<verb-s-pv> &
{TOf+ or THi+ or Z-}) or ({@E-} & A+) or ({@MV+} & {TO+} & <verb-po>);
expecting.g claiming.g: (<vc-expect> & <verb-ge>) or <verb-ge-d>;
expecting.v claiming.v: <verb-pg> & <vc-expect>;

<vc-intend>: ({@MV+} & (TH+ or Z- or TO+)) or
((O+ or OX+ or B-) & {@MV+} & TOo+);
intend.v: <verb-pl,i> & <vc-intend>;
intends.v: <verb-s> & <vc-intend>;
intended.v: (<verb-sp,pp> & <vc-intend>) or (<verb-pv> & {TO+ or Z- or @MV+})
 or ({@E-} & A+) or ({@MV+} & {TO+} & <verb-po>);
intending.g: (<vc-intend> & <verb-ge>) or <verb-ge-d>;
intending.v: <verb-pg> & <vc-intend>;

<vc-dare>: (N+ & I+) or ({@MV+} & TO+) or ((O+ or B-) & {@MV+} & TOo+); 
dare.v: <verb-pl,i> & <vc-dare>;
dares.v: <verb-s> & <vc-dare>;
dared: (<verb-sp,pp> & <vc-dare>) or (<verb-pv> & TO+) or 
({@MV+} & TO+ & <verb-po>);
daring.g: (<vc-dare> & <verb-ge>) or <verb-ge-d>;
daring.v: <verb-pg> & <vc-dare>;

<vc-like>: ({@MV+} & (TO+ or Pg+)) or ((O+ or B- or OX+) & {@MV+} & {TOo+})
or ([[@MV+ & O*n+]]);
like.v: <verb-pl,i> & <vc-like>;
likes.v: <verb-s> & <vc-like>;
liked.v: (<verb-sp,pp> & <vc-like>) or <verb-pv> or <verb-po>;
liking.g: (<vc-like> & <verb-ge>) or <verb-ge-d>;
liking.v: <verb-pg> & <vc-like>;

<vc-offer>: (((O+ & {{[[@MV+]]} & O*n+}) or (B- & {O+})) & {@MV+}) or 
({@MV+} & TO+) or ([[@MV+ & O*n+]]);
offer.v: <verb-pl,i> & <vc-offer>;
offers.v: <verb-s> & <vc-offer>;
offered.v: (<verb-sp,pp> & <vc-offer>) or (<verb-pv-b> & {O+ or B-
or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or [[@MV+ & O*n+]]} or <verb-po>);
offering.g: (<vc-offer> & <verb-ge>) or <verb-ge-d>;
offering.v: <verb-pg> & <vc-offer>;

<vc-refuse>: (((O+ & {{[[@MV+]]} & O*n+}) or (B- & {O+})) & {@MV+}) or 
({@MV+} & {TO+}) or ([[@MV+ & O*n+]]);
refuse.v: <verb-pl,i> & <vc-refuse>;
refuses.v: <verb-s> & <vc-refuse>;
refused.v: (<verb-sp,pp> & <vc-refuse>) or (<verb-pv-b> & {O+ or B- or
[[@MV+ & O*n+]]} & {@MV+}) or ({O+ or [[@MV+ & O*n+]]} & <verb-po>);
refusing.g: (<vc-refuse> & <verb-ge>) or <verb-ge-d>;
refusing.v: <verb-pg> & <vc-refuse>;

<vc-want>: ({@MV+} & TO+) or ((O+ or OX+ or B-) & {@MV+} & {TOo+ or Pv+}) or
([[@MV+ & O*n+]]) or [[CX- & {@MV+}]];
want.v need.v: <verb-pl,i> & <vc-want>;
need.i: {@E-} & (S- or (RS- & B-)) & (N+ & I+);
wants.v needs.v: <verb-s> & <vc-want>;
wanted.v needed.v: (<verb-sp,pp> & <vc-want>) or <verb-pv> or ({@E-} & A+)
or <verb-po>;
wanting.g needing.g: (<vc-want> & <verb-ge>) or <verb-ge-d>;
wanting.v needing.v: <verb-pg> & <vc-want>;

<vc-choose>: ({@MV+} & {TO+}) or ((O+ or B-) & {@MV+} & {TOo+}) or 
([[@MV+ & O*n+]]);
choose.v: <verb-pl,i> & <vc-choose>;
chooses.v: <verb-s> & <vc-choose>;
chose.v: <verb-sp> & <vc-choose>;
chosen.v: (<verb-pp> & <vc-choose>) or (<verb-pv> & {TO+}) or ({@E-} & A+)
or ({@MV+} & {TO+} & <verb-po>);
choosing.g: (<vc-choose> & <verb-ge>) or <verb-ge-d>;
choosing.v: <verb-pg> & <vc-choose>;

<vc-prepare>: ({@MV+} & {TO+}) or ((O+ or B-) & {@MV+} & {TOo+}) or
([[@MV+ & O*n+]]);
prepare.v press.v: <verb-pl,i> & <vc-prepare>;
prepares.v presses.v: <verb-s> & <vc-prepare>;
prepared.v pressed.v: (<verb-sp,pp> & <vc-prepare>) or <verb-pv> or 
({@E-} & A+) or <verb-po>;
preparing.g pressing.g: (<vc-prepare> & <verb-ge>) or <verb-ge-d>;
preparing.v pressing.v: <verb-pg> & <vc-prepare>;

<vc-require>: ((O+ or B-) & {@MV+} & {TOo+}) or
 ({@MV+} & (TH+ or Ce+ or TS+ or (SI*j+ & I*j+))) or Zs- or
([[@MV+ & O*n+]]);
require.v: <verb-pl,i> & <vc-require>;
requires.v: <verb-s> & <vc-require>;
required.v: (<verb-sp,pp> & <vc-require>) or 
(<verb-pv> & {TO+ or TSi+}) or ({@E-} & A+) or ({@MV+} & {TO+} & <verb-po>);
requiring.g: (<vc-require> & <verb-ge>) or <verb-ge-d>;
requiring.v: <verb-pg> & <vc-require>;

<vc-command>: ({@MV+} & (TH+ or Zs- or TS+)) or
((O+ or B-) & {@MV+} & {TOo+}) or ([[@MV+ & O*n+]]);
command.v order.v urge.v: <verb-pl,i> & <vc-command>;
commands.v orders.v urges.v: <verb-s> & <vc-command>;
commanded.v ordered.v urged.v: 
(<verb-sp,pp> & <vc-command>) or (<verb-pv> & {TO+ or TH+ or TS+}) 
or ({@MV+} & {TH+ or TO+ or TS+} & <verb-po>);
commanding.g ordering.g urging.g: (<vc-command> & <verb-ge>) or <verb-ge-d>;
commanding.v ordering.v urging.v: <verb-pg> & <vc-command>;

<vc-consider>: ({@MV+} & (TH+ or Pg+)) or ((O+ or OX+ or B-) & {@MV+} & {TOo+
or Pa+}) or (((O+ & (B- or ({[[@MV+]]} & O*n+))) or 
([[@MV+ & O*n+]])) & {@MV+});
consider.v: <verb-pl,i> & <vc-consider>;
considers.v: <verb-s> & <vc-consider>;
considered.v: (<verb-sp,pp> & <vc-consider>) or (<verb-s-pv-b> & 
(({@MV+} & (TOf+ or Pa+)) or ({O+ or B- or [[@MV+ & O*n+]]} & {@MV+})))
or ((({@MV+} & (TOf+ or Pa+)) or ({O+ or [[@MV+ & O*n+]]}))
& <verb-po>);
considering.g: (<vc-consider> & <verb-ge>) or <verb-ge-d>;
considering.v: <verb-pg> & <vc-consider>;

<vc-perceive>: ({@MV+} & (TH+ or Ce+)) or ((O+ or OX+ or B-) & {@MV+} & {TOo+})
or ([[@MV+ & O*n+]]);
perceive.v: <verb-pl,i> & <vc-perceive>;
perceives.v: <verb-s> & <vc-perceive>;
perceived.v: (<verb-sp,pp> & <vc-perceive>) or (<verb-pv> & {TO+}) or 
({@E-} & A+) or ({@MV+} & {TO+} & <verb-po>);
perceiving.g: (<vc-perceive> & <verb-ge>) or <verb-ge-d>;
perceiving.v: <verb-pg> & <vc-perceive>;

<vc-report>: ({@MV+} & {TH+ or Z- or Ce+}) or 
((O+ or B-) & {@MV+} & {TOo+}) or ([[@MV+ & O*n+]]);
report.v: <verb-pl,i> & <vc-report>;
reports.v: <verb-s> & <vc-report>;
reported.v: (<verb-sp,pp> & <vc-report>) or (<verb-s-pv> & {TOf+ or Z-}) or 
({@E-} & A+) or ({@MV+} & {TO+} & <verb-po>);
reporting.g: (<vc-report> & <verb-ge>) or <verb-ge-d>;
reporting.v: <verb-pg> & <vc-report>;

<vc-caution>: ((O+ or B-) & {@MV+} & 
{TH+ or Ce+ or TOo+}) or ({@MV+} & {TH+ or Zs-}) or ([[@MV+ & O*n+]]);
caution.v: <verb-pl,i> & <vc-caution>;
cautions.v: <verb-s> & <vc-caution>;
cautioned.v: (<verb-sp,pp> & <vc-caution>) or (<verb-pv> &
((O+ or B-) & {@MV+} & 
{TH+ or Ce+ or Zs- or TO+})) or ({@MV+} & {TH+ or Ce+ or TO+} & <verb-po>);
cautioning.g: (<vc-caution> & <verb-ge>) or <verb-ge-d>;
cautioning.v: <verb-pg> & <vc-caution>;

<vc-warn>: ((O+ or B-) & {@MV+} & 
{TH+ or Ce+ or TOo+ or (OF+ & {@MV+})}) or 
({@MV+} & {TH+ or Zs- or (OF+ & {@MV+})}) or ([[@MV+ & O*n+]]);
warn.v advise.v: <verb-pl,i> & <vc-warn>;
warns.v advises.v: <verb-s> & <vc-warn>;
warned.v advised.v: 
(<verb-sp,pp> & <vc-warn>) or (<verb-pv> &
{TH+ or Ce+ or Zs- or TO+ or (OF+ & {@MV+})}) 
or ({@MV+} & {TH+ or Ce+ or TO+ or OF+} & <verb-po>);
warning.g advising.g: (<vc-warn> & <verb-ge>) or <verb-ge-d>;
warning.v advising.v: <verb-pg> & <vc-warn>;

<vc-hear>: ((B- or O+) &
{@MV+} & {I*j+ or Pg+}) or ({@MV+} & {TH+ or Zs- or Ce+ or
(OF+ & {@MV+})}) or ([[@MV+ & O*n+]]);
hear.v: <verb-pl,i> & <vc-hear>;
hears.v: <verb-s> & <vc-hear>;
heard.v: (<verb-sp,pp> & <vc-hear>) or (<verb-pv> & {Pg+}) or ({@MV+} & 
{Pg+} & <verb-po>);
hearing.g: (<vc-hear> & <verb-ge>) or <verb-ge-d>;
hearing.v: <verb-pg> & <vc-hear>;

<vc-see>: ((B- or O+) &
{@MV+} & {I*j+ or Pg+ or AZ+ or Pv+}) or ({@MV+} & {TH+ or Zs- or QI+
or Ce+}) or ([[@MV+ & O*n+]]);
see.v: <verb-pl,i> & <vc-see>;
sees.v: <verb-s> & <vc-see>;
saw.v: <verb-sp> & <vc-see>;
seen.v: (<verb-pp> & <vc-see>) or (<verb-pv> & {Pg+ or AZ+}) or
({@MV+} & {Pg+ or AZ+} & <verb-po>);
seeing.g: (<vc-see> & <verb-ge>) or <verb-ge-d>;
seeing.v: <verb-pg> & <vc-see>;

<vc-owe>: ((O+ & {{[[@MV+]]} & O*n+}) or (B- & {O+}) or 
([[@MV+ & O*n+]])) & {@MV+};
owe.v deliver.v accord.v award.v term.v grant.v begrudge.v assign.v rename.v repay.v
dub.v entitle.v fine.v: 
<verb-pl,i> & <vc-owe>;
owes.v delivers.v accords.v awards.v terms.v grants.v begrudges.v assigns.v renames.v
repays.v dubs.v entitles.v fines.v: 
 <verb-s> & <vc-owe>;
owed.v delivered.v accorded.v awarded.v termed.v
granted.v begrudged.v assigned.v renamed.v repaid.v dubbed.v entitled.v fined.v: 
(<verb-sp,pp> & <vc-owe>) or (<verb-pv-b> &
{O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or 
({O+ or [[@MV+ & O*n+]]} & <verb-po>);
owing.v delivering.v according.v awarding.v terming.v granting.v
begrudging.v assigning.v renaming.v repaying.v dubbing.v entitling.v fining.v: 
<verb-pg> & <vc-owe>;
owing.g delivering.g according.g awarding.g terming.g granting.g begrudging.g
assigning.g renaming.g repaying.g dubbing.g entitling.g fining.g: 
(<vc-owe> & <verb-ge>) or <verb-ge-d>;

<vc-give>: ((B- & {O+ or K+}) or (O+ & {({[[@MV+]]} & [O*n+]) or K+}) or 
(K+ & ({[[@MV+]]} & O*n+)) or ([[@MV+ & O*n+]])) & {@MV+};
give.v send.v buy.v bring.v lend.v issue.v hand.v: <verb-pl,i> & <vc-give>;
gives.v sends.v buys.v brings.v lends.v
issues.v hands.v: <verb-s> & <vc-give>;
sent.v bought.v brought.v lent.v handed.v: (<verb-sp,pp> & <vc-give>)
or (<verb-pv-b> & {O+ or B- or K+ or [[@MV+ & O*n+]]} & {@MV+}) 
or ({O+ or K+ or [[@MV+ & O*n+]]} & <verb-po>);
issued.v: (<verb-sp,pp> & <vc-give>)
or (<verb-pv-b> & {O+ or B- or K+ or [[@MV+ & O*n+]]} & {@MV+}) 
or ({O+ or K+ or [[@MV+ & O*n+]]} & <verb-po>) or ({@E-} & A+);
gave.v: <verb-sp> & <vc-give>;
given.v: (<verb-pp> & <vc-give>) or (<verb-pv-b> & {O+ or B- or K+
or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or K+ or [[@MV+ & O*n+]]} & <verb-po>);
giving.g sending.g buying.g bringing.g 
lending.g issuing.g handing.g: (<vc-give> & <verb-ge>) or <verb-ge-d>;
giving.v sending.v buying.v bringing.v lending.v issuing.v
handing.v: <verb-pg> & <vc-give>;

<vc-pass>: {(B- & {O+ or K+}) or (O+ & {({[[@MV+]]} & O*n+) or K+}) or 
(K+ & {{[[@MV+]]} & O*n+}) or ([[@MV+ & O*n+]])} & {@MV+};
pass.v pay.v sell.v deal.v: <verb-pl,i> & <vc-pass>;
passes.v pays.v sells.v deals.v: <verb-s> & <vc-pass>;
passed.v paid.v sold.v dealt.v: 
(<verb-sp,pp> & <vc-pass>) or (<verb-pv-b> & {O+ or B- or K+
or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or K+ or [[@MV+ & O*n+]]} & <verb-po>);
passing.g paying.g selling.g dealing.g: 
(<vc-pass> & <verb-ge>) or <verb-ge-d>;
passing.v paying.v selling.v dealing.v: <verb-pg> & <vc-pass>;

<vc-call>: {(B- & {O+ or Pa+ or K+}) or (O+ & {({[[@MV+]]} & O*n+) or 
Pa+ or K+}) or (K+ & {{[[@MV+]]} & O*n+}) or ([[@MV+ & O*n+]])} & {@MV+};
call.v: <verb-pl,i> & <vc-call>;
calls.v: <verb-s> & <vc-call>;
called.v: (<verb-sp,pp> & <vc-call>) or (<verb-pv-b> & {O+ or B- or K+ or Pa+
or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or K+ or Pa+ or 
[[@MV+ & O*n+]]} & <verb-po>);
calling.g: (<vc-call> & <verb-ge>) or <verb-ge-d>;
calling.v: <verb-pg> & <vc-call>;

<vc-write>: ({(B- & {O+ or K+}) or (O+ & {({[[@MV+]]} & O*n+) or K+}) or 
(K+ & {{[[@MV+]]} & O*n+}) or ([[@MV+ & O*n+]])} & {@MV+})
or ({@MV+} & (TH+ or Ce+));
write.v charge.v: <verb-pl,i> & <vc-write>;
writes.v reads.v charges.v: <verb-s> & <vc-write>;
wrote.v: <verb-sp> & <vc-write>;
read.v: ((<verb-pl,i> or <verb-sp,pp>) & <vc-write>) or (<verb-pv-b> &
{O+ or B- or K+ or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or K+ or 
[[@MV+ & O*n+]]} & <verb-po>);
charged.v: (<verb-sp,pp> & <vc-write>) or (<verb-pv-b> & {O+ or B- or K+
or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or K+ or [[@MV+ & O*n+]]} & <verb-po>);
written.v: (<verb-pp> & <vc-write>) or (<verb-pv-b> & {O+ or B- or K+
or [[@MV+ & O*n+]]} & {@MV+}) or ({O+ or K+ or [[@MV+ & O*n+]]} & <verb-po>)
or ({@E-} & A+);
writing.g reading.g charging.g: (<vc-write> & <verb-ge>) or <verb-ge-d>;
writing.v reading.v charging.v: <verb-pg> & <vc-write>;

<vc-allow>: (((O+ & {[[@MV+]]} & O*n+) or ([[@MV+]] & O*n+)) & {@MV+}) or 
((O+ or B-) & {@MV+} & {B- or TOo+});
allow.v: <verb-pl,i> & <vc-allow>;
allows.v: <verb-s> & <vc-allow>;
allowed.v: (<verb-sp,pp> & <vc-allow>) or 
(<verb-pv-b> & (({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or ({@MV+} & TO+)))
or ({O+ or [[@MV+ & O*n+]] or ({@MV+} & TO+)} & <verb-po>);
allowing.g: (<vc-allow> & <verb-ge>) or <verb-ge-d>;
allowing.v: <verb-pg> & <vc-allow>;

<vc-promise>:
({O+ or B-} & {@MV+} & {B- or TO+ or Ce+ or TH+ or RSe+ or Zs-}) or 
(((O+ & {[[@MV+]]} & O*n+) or ([[@MV+ & O*n+]])) & {@MV+});
promise.v: <verb-pl,i> & <vc-promise>;
promises.v: <verb-s> & <vc-promise>;
promised.v: (<verb-sp,pp> & <vc-promise>) or (<verb-pv-b> & 
(({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or 
({@MV+} & (TO+ or Ce+ or TH+ or RSe+ or Zs-)))) or ({@E-} & A+) or
({O+ or [[@MV+ & O*n+]] or ({{@MV+} & (TO+ or Ce+ or TH+)})} & <verb-po>);
promising.g: (<vc-promise> & <verb-ge>) or <verb-ge-d>;
promising.v: <verb-pg> & <vc-promise>;

<vc-show>: ({O+ or B-} & ({@MV+} & (QI+ or Ce+ or TH+ or RSe+ or Zs- or B-)))
or (((O+ & {K+ or ({[[@MV+]]} & O*n+)}) or (K+ & (B- or ({[[@MV+]]} & O*n+))) 
or ([[@MV+ & O*n+]]) or [[()]]) & {@MV+});
show.v: <verb-pl,i> & <vc-show>;
shows.v: <verb-s> & <vc-show>;
showed.v: <verb-sp> & <vc-show>;
shown.v: (<verb-pp> & <vc-show>) or (<verb-s-pv-b> & 
(({O+ or K+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or
({@MV+} & (QI+ or Ce+ or TH+ or RSe+ or Zs-)))) or 
({O+ or K+ or [[@MV+ & O*n+]] or ({@MV+} & (QI+ or Ce+ or TH+))} & <verb-po>);
showing.g: (<vc-show> & <verb-ge>) or <verb-ge-d>;
showing.v: <verb-pg> & <vc-show>;

<vc-teach>: ((O+ or B-) & ({@MV+} & (QI+ or Ce+ or TH+ or RSe+ or Zs- or B-
or TOo+))) or
({((O+ or B-) & ({[[@MV+]]} & O*n+)) or ([[@MV+ & O*n+]])} & {@MV+});
teach.v: <verb-pl,i> & <vc-teach>;
teaches.v: <verb-s> & <vc-teach>;
taught.v: (<verb-sp,pp> & <vc-teach>) or (<verb-pv-b> & 
(({O+ or B- or [[@MV+ & O*n+]]} & {@MV+}) or
({@MV+} & (QI+ or Ce+ or TH+ or RSe+ or Zs- or TO+)))) or 
({O+ or [[@MV+ & O*n+]] or ({@MV+} & (QI+ or Ce+ or TH+))} & <verb-po>);
teaching.g: (<vc-teach> & <verb-ge>) or <verb-ge-d>;
teaching.v: <verb-pg> & <vc-teach>;

<vc-compel>: ((O+ or B-) & {@MV+} & TOo+);
compel.v: <verb-pl,i> & <vc-compel>;
compels.v: <verb-s> & <vc-compel>;
compelled.v: (<verb-sp,pp> & <vc-compel>) or (<verb-pv> & TO+)
or ({@MV+} & TO+ & <verb-po>);
compelling.v: <verb-pg> & <vc-compel>;
compelling.g: (<vc-compel> & <verb-ge>) or <verb-ge-d>;

<vc-force>: (((O+ or B-) & (({@MV+} & TOo+) or K+ or [()])) or (K+ & O*n+)
or ([[{K+} & @MV+ & O*n+]])) & {@MV+};
force.v: <verb-pl,i> & <vc-force>;
forces.v: <verb-s> & <vc-force>;
forced.v: (<verb-sp,pp> & <vc-force>) or (<verb-pv-b> & ((K+ & {@MV+}) or 
({@MV+} & TO+))) or ((K+ or ({@MV+} & TO+)) & <verb-po>) or ({@E-} & A+);
forcing.g: (<vc-force> & <verb-ge>) or <verb-ge-d>;
forcing.v: <verb-pg> & <vc-force>;

<vc-design>: ((O+ or B-) & {@MV+} & {TOo+}) or ([[@MV+ & O*n+ & {@MV+}]]);
design.v permit.v authorize.v use.v cause.v enable.v
pressure.v train.v sentence.v prompt.v spur.v
invite.v reelect.v encourage.v draft.v hire.v entice.v inspire.v aid.v
forbid.v employ.v educate.v tempt.v condemn.v commission.v counsel.v induce.v instruct.v
license.v incite.v nominate.v destine.v provoke.v challenge.v exhort.v
implore.v motivate.v impel.v: 
<verb-pl,i> & <vc-design>;
designs.v permits.v pressures.v trains.v sentences.v causes.v enables.v
authorizes.v uses.v prompts.v spurs.v 
invites.v reelects.v encourages.v drafts.v hires.v entices.v inspires.v aids.v
forbids.v employs.v educates.v tempts.v condemns.v commissions.v counsels.v induces.v
instructs.v licenses.v incites.v nominates.v destines.v provokes.v
challenges.v exhorts.v implores.v motivates.v impels.v: 
<verb-s> & <vc-design>;
designed.v permitted.v pressured.v trained.v sentenced.v caused.v enabled.v
authorized.v prompted.v spurred.v invited.v
reelected.v encouraged.v drafted.v hired.v enticed.v inspired.v aided.v employed.v
educated.v tempted.v condemned.v commissioned.v counseled.v induced.v instructed.v
licensed.v incited.v nominated.v destined.v provoked.v challenged.v exhorted.v
implored.v motivated.v impelled.v:
(<verb-sp,pp> & <vc-design>) or (<verb-pv> & {TO+}) or ({@E-} & A+)
or ({{@MV+} & TO+} & <verb-po>);
forbade.v: <verb-sp> & <vc-design>;
forbidden.v: (<verb-pp> & <vc-design>) or (<verb-pv> & {TO+}) or ({@E-} & A+)
or ({{@MV+} & TO+} & <verb-po>);
designing.g permitting.g pressuring.g causing.g enabling.g
training.g sentencing.g authorizing.g prompting.g 
spurring.g inviting.g 
reelecting.g encouraging.g drafting.g hiring.g
enticing.g inspiring.g aiding.g employing.g educating.g tempting.g
condemning.g commissioning.g counseling.g inducing.g instructing.g 
licensing.g inciting.g nominating.g destining.g provoking.g challenging.g
exhorting.g imploring.g motivating.g impelling.g:
(<vc-design> & <verb-ge>) or <verb-ge-d>;
designing.v permitting.v pressuring.v causing.v enabling.v
training.v sentencing.v authorizing.v using.v prompting.v 
spurring.v inviting.v reelecting.v encouraging.v drafting.v hiring.v
enticing.v inspiring.v aiding.v employing.v educating.v tempting.v
condemning.v commissioning.v counseling.v inducing.v instructing.v 
licensing.v inciting.v nominating.v destining.v provoking.v challenging.v
exhorting.v imploring.v motivating.v impelling.v:
<verb-pg> & <vc-design>;
used.v: (<verb-sp,pp> & <vc-design>) or (<verb-pv> & {TOo+}) or (<verb-sp> & 
TO+) or ({@MV+} & {TOo+} & <verb-po>) or ({@E-} & A+);
using.g: (<vc-design> & (<verb-ge> or MVs-)) or <verb-ge-d>;

<vc-elect>: ((O+ or B-) & (({@MV+} & {TOo+}) or ({[[@MV+]]} & (O*n+ or TI+))))
 or ([[@MV+ & O*n+ & {@MV+}]]);
elect.v appoint.v: <verb-pl,i> & <vc-elect>;
elects.v appoints.v: <verb-s> & <vc-elect>;
elected.v appointed.v: (<verb-sp,pp> & <vc-elect>) or (<verb-pv-b> & (({B- or
(O+ or TI+ or [[@MV+ & (O*n+ or TI+)]])} & {@MV+}) or ({@MV+} & TO+))) 
or (({O+ or TI+ or [[@MV+ & (O*n+ or TI+)]]} or ({@MV+} & TO+)) & <verb-po>)
or ({@E-} & A+);
electing.g appointing.g: (<vc-elect> & <verb-ge>) or <verb-ge-d>;
electing.v appointing.v: <verb-pg> & <vc-elect>;

<vc-name>: ((O+ & {{[[@MV+]]} & (O*n+ or TI+)}) or (B- & {O+ or TI+}) or 
([[@MV+ & O*n+]])) & {@MV+};
name.v: <verb-pl,i> & <vc-name>;
names.v: <verb-s> & <vc-elect>;
named.v: (<verb-sp,pp> & <vc-name>) or (<verb-pv-b> & ({B- or
(O+ or TI+ or [[@MV+ & (O*n+ or TI+)]])}) & {@MV+}) or 
({O+ or TI+ or [[@MV+ & (O*n+ or TI+)]]} & <verb-po>);
naming.g: (<vc-name> & <verb-ge>) or <verb-ge-d>;
naming.v: <verb-pg> & <vc-name>;

<vc-program>: {((O+ or B-) & {@MV+} & {TOo+}) or @MV+ or ([[@MV+ & O*n+ & {@MV+}]])};
program.v oblige.v: <verb-pl,i> & <vc-program>;
programs.v obliges.v: <verb-s> & <vc-program>;
programmed obliged.v: (<verb-sp,pp> & <vc-program>) or (<verb-pv> & {TO+}) or 
({@E-} & A+) or ({{@MV+} & TO+} & <verb-po>);
programming.g obliging.g: (<vc-program> & <verb-ge>) or <verb-ge-d>;
programming.v obliging.v: <verb-pg> & <vc-program>;

<vc-convince>: ((O+ or B-) & {@MV+} & {TOo+ or TH+ or Ce+}) or 
([[@MV+ & O*n+ & {@MV+}]]);
convince.v persuade.v: <verb-pl,i> & <vc-convince>;
convinces.v persuades.v: <verb-s> & <vc-convince>;
convinced.v persuaded.v: (<verb-sp,pp> & <vc-convince>) or (<verb-pv> & 
{TO+ or TH+ or Ce+}) or ({{@MV+} & (TO+ or TH+ or Ce+)} & <verb-po>);
convincing.g persuading.g: (<vc-convince> & <verb-ge>) or <verb-ge-d>;
convincing.v persuading.v: <verb-pg> & <vc-convince>;

<vc-tell>: ((O+ or B-) & {@MV+} & 
{TH+ or Ce+ or RSe+ or Zs- or TOo+ or QI+ or BW-}) or ([[@MV+ & O*n+ & {@MV+}]]);
tell.v: <verb-pl,i> & <vc-tell>;
tell.i: {@E-} & I- & {@MV+} & (QI+ or TH+ or Ce+ or RSe+ or Zs-);
tells.v: <verb-s> & <vc-tell>;
told.v: (<verb-sp,pp> & <vc-tell>) or (<verb-pv> & 
{TH+ or Ce+ or RSe+ or Zs- or TO+ or QI+ or BW-}) or ({{@MV+} &
(Ce+ or TO+ or QI+ or TH+)} & <verb-po>);
telling.g: (<vc-tell> & <verb-ge>) or <verb-ge-d>;
telling.v: <verb-pg> & <vc-tell>;

<vc-ask>: ({O+ or B-} & {@MV+} & {TS+ or TOo+ or QI+ or BW-}) or 
([[@MV+ & O*n+ & {@MV+}]]);
ask.v: <verb-pl,i> & <vc-ask>;
asks.v: <verb-s> & <vc-ask>;
asked.v: (<verb-sp,pp> & <vc-ask>) or (<verb-pv> & {TO+ or QI+ or BW- or TH+ or
 TS+}) or ({{@MV+} & (TO+ or QI+ or TH+ or TS+)} & <verb-po>);
asking.g: (<vc-ask> & <verb-ge>) or <verb-ge-d>;
asking.v: <verb-pg> & <vc-ask>;

<vc-help>: ({O+ or B-} & {@MV+} & {TO+ or I+}) or ([[@MV+ & O*n+ & {@MV+}]]);
help.v: <verb-pl,i> & <vc-help>;
helps.v: <verb-s> & <vc-help>;
helped.v: (<verb-sp,pp> & <vc-help>) or (<verb-pv> & {TO+}) or 
({{@MV+} & TO+} & <verb-po>);
helping.g: (<vc-help> & <verb-ge>) or <verb-ge-d>;
helping.v: <verb-pg> & <vc-help>;

<vc-remind>: ((O+ or B-) & {@MV+} & (TOo+ or TH+ or Ce+ or (OF+ & {@MV+}))) or
([[@MV+ & O*n+ & {@MV+}]]);
remind.v: <verb-pl,i> & <vc-remind>;
reminds.v: <verb-s> & <vc-remind>;
reminded.v: (<verb-sp,pp> & <vc-remind>) or (<verb-pv> & {TO+ or TH+ or Ce+ or 
(OF+ & {@MV+})}) or ({{@MV+} & (Ce+ or TO+ or TH+ or 
(OF+ & {@MV+}))} & <verb-po>);
reminding.g: (<vc-remind> & <verb-ge>) or <verb-ge-d>;
reminding.v: <verb-pg> & <vc-remind>;

<vc-inform>: ((O+ or B-) & {@MV+} & {(OF+ & {@MV+}) or TH+ or Zs- or Ce+}) or 
([[@MV+ & O*n+ & {@MV+}]]);
inform.v reassure.v alert.v guarantee.v notify.v forewarn.v: 
<verb-pl,i> & <vc-inform>;
informs.v reassures.v alerts.v guarantees.v notifies.v forewarns.v: 
<verb-s> & <vc-inform>;
informed.v reassured.v alerted.v guaranteed.v notified.v forewarned.v: 
(<verb-sp,pp> & <vc-inform>) or (<verb-pv> & 
{Ce+ or TH+ or Zs- or (OF+ & {@MV+})}) or ({{@MV+} & (Ce+ or
TH+ or OF+)} & <verb-po>) or ({@E-} & A+);
informing.g reassuring.g alerting.g guaranteeing.g notifying.g forewarning.g: 
(<vc-inform> & <verb-ge>) or <verb-ge-d>;
informing.v reassuring.v alerting.v guaranteeing.v notifying.v forewarning.v: 
<verb-pg> & <vc-inform>;

<vc-assure>: ((O+ or B-) & {@MV+} & {(OF+ & {@MV+}) or TH+ or Zs- or Ce+}) 
or ([[@MV+ & O*n+ & {@MV+}]]) or ({@MV+} & (TH+ or Ce+));
assure.v: <verb-pl,i> & <vc-assure>;
assures.v: <verb-s> & <vc-assure>;
assured.v: (<verb-sp,pp> & <vc-assure>) or (<verb-pv> & 
{(OF+ & {@MV+}) or Ce+ or TH+ or Zs-}) or ({{@MV+} & (Ce+ or 
TH+ or OF+)} & <verb-po>);
assuring.g: (<vc-assure> & <verb-ge>) or <verb-ge-d>;
assuring.v: <verb-pg> & <vc-assure>;

<vc-let>: ((B- or O+) & {@MV+} & {I+ or ((K+ or Pp+) & {@MV+})}) 
or ([[@MV+ & O*n+ & {@MV+}]]);
let.v: ((<verb-pl,i> or <verb-sp,pp>) & <vc-let>) or (<verb-pv-b> 
& ((K+ or Pp+) & {@MV+})) or ((K+ or Pp+) & <verb-po>);
lets.v: <verb-s> & <vc-let>;
letting.g: (<vc-let> & <verb-ge>) or <verb-ge-d>;
letting.v: <verb-pg> & <vc-let>;

let's: Wi- & I+;

<vc-watch>: ((B- or O+) & {@MV+} & {I*j+ or Pg+}) or ([[@MV+ & O*n+ & {@MV+}]])
or {@MV+};
watch.v: <verb-pl,i> & <vc-watch>;
watches.v: <verb-s> & <vc-watch>;
watched.v: (<verb-sp,pp> & <vc-watch>) or <verb-pv> or <verb-po>;
watching.g: (<vc-watch> & <verb-ge>) or <verb-ge-d>;
watching.v: <verb-pg> & <vc-watch>;

<vc-appreciate>: ((B- or O+) & {@MV+} & {Pg+}) or ([[@MV+ & O*n+ & {@MV+}]]);
appreciate.v spend.v: <verb-pl,i> & <vc-appreciate>;
appreciates.v spends.v: <verb-s> & <vc-appreciate>;
appreciated.v spent.v: (<verb-sp,pp> & <vc-appreciate>) or (<verb-pv> & {Pg+})
or ({{@MV+} & Pg+} & <verb-po>);
appreciating.g spending.g: (<vc-appreciate> & <verb-ge>) or <verb-ge-d>;
appreciating.v spending.v: <verb-pg> & <vc-appreciate>;

<vc-make>: ((B- or O+ or OX+) & {({@MV+} & {I*j+ or Pa**j+ or B-}) or 
((K+ or AF-) & {@MV+})}) or ((((O+ or K+) & {[[@MV+]]} & O*n+) or K+ or Vm+ or
([[{K+} & @MV+ & O*n+]])) & {@MV+});
make.v: <verb-pl,i> & <vc-make>;
makes.v: <verb-s> & <vc-make>;
made.v: (<verb-sp,pp> & <vc-make>) or (<verb-s-pv-b> & 
(({@MV+} & Pa+) or ({K+} & {@MV+}))) or ({({@MV+} & Pa+) or K+} & 
<verb-po>);
made_of made_up_of: (<verb-pv-b> & (B- or O+) & {@MV+}) or (O+ & <verb-po>);
making.g: (<vc-make> & <verb-ge>) or <verb-ge-d>;
making.v: <verb-pg> & <vc-make>;

<vc-render>: (((B- or O+) & {({@MV+} & Pa+) or AF-}) or ([[@MV+ & O*n+]]))
 & {@MV+};
render.v deem.v: <verb-pl,i> & <vc-render>;
renders.v deems.v: <verb-s> & <vc-render>;
rendered.v deemed.v: (<verb-sp,pp> & <vc-render>) or (<verb-pv> & {Pa+ or AF-})
or ({{@MV+} & Pa+} & <verb-po>);
rendering.g deeming.g: (<vc-render> & <verb-ge>) or <verb-ge-d>;
rendering.v deeming.v: <verb-pg> & <vc-render>;

<vc-deprive>: (((O+ or B-) & {{@MV+} & OF+}) or ([[@MV+ & O*n+]])) & {@MV+};
deprive.v accuse.v acquit.v purge.v disabuse.v exonerate.v absolve.v rob.v
convict.v: <verb-pl,i> & <vc-deprive>;
deprives.v accuses.v acquits.v purges.v disabuses.v
exonerates.v absolves.v robs.v convicts.v: <verb-s> & <vc-deprive>;
deprived.v accused.v acquitted.v purged.v disabused.v exonerated.v absolved.v robbed.v
convicted.v: (<verb-sp,pp> & <vc-deprive>) or (<verb-pv> & {OF+} & {@MV+}) 
or ({@E-} & A+) or ({{@MV+} & OF+} & <verb-po>);
depriving.g accusing.g acquitting.g purging.g disabusing.g exonerating.g
absolving.g robbing.g convicting.g: 
(<vc-deprive> & <verb-ge>) or <verb-ge-d>;
depriving.v accusing.v acquitting.v purging.v disabusing.v
exonerating.v absolving.v robbing.v convicting.v: <verb-pg> & <vc-deprive>;

<vc-clear>: (((O+ or B-) & {({@MV+} & OF+) or K+}) or 
({K+} & O*n+) or K+ or ([[{K+} & @MV+ & O*n+]])) & {@MV+};
clear.v: <verb-pl,i> & <vc-clear>;
clears.v: <verb-s> & <vc-clear>;
cleared.v: (<verb-sp,pp> & <vc-clear>) or (<verb-pv-b> & {({@MV+} & OF+)
 or K+} & {@MV+}) or ({K+ or ({@MV+} & OF+)} & <verb-po>);
clearing.g: (<vc-clear> & <verb-ge>) or <verb-ge-d>;
clearing.v: <verb-pg> & <vc-clear>;

<vc-bet>: ({(O+ & {O*n+}) or (B- & {O+})} & {@MV+} & {TH+ or Ce+ or RSe+})
or ([[@MV+ & O*n+ & {@MV+}]]);
bet.v: ((<verb-pl,i> or <verb-sp,pp>) & <vc-bet>) or (<verb-pv> & {O+ or B-} &
{@MV+} & {TH+ or Ce+ or RSe+ or @MV+}); 
bets.v: <verb-s> & <vc-bet>;
betted.v: (<verb-sp,pp> & <vc-bet>) or (<verb-pv-b> & {O+ or B-} & {@MV+}
& {TH+ or Ce+ or RSe+ or @MV+}) or ({O- or [[@MV+ & O*n+]] or TH+ or Ce+}
& <verb-po>); 
betting.g: (<vc-bet> & <verb-ge>) or <verb-ge-d>;
betting.v: <verb-pg> & <vc-bet>;

<vc-bother>: ({@MV+} & TO+) or ((O+ or B-) & {@MV+} & {THi+}) or 
([[@MV+ & O*n+ & {@MV+}]]);
bother.v: <verb-s-pl,i> & <vc-bother>;
bothers.v: <verb-s-s> & <vc-bother>;
bothered.v: (<verb-s-sp,pp> & <vc-bother>) or <verb-pv> or <verb-po>;
bothering.v: <verb-s-pg> & <vc-bother>;
bothering.g: (<vc-bother> & <verb-ge>) or <verb-ge-d>;

<vc-surprise>: ((O+ or B-) & {@MV+} & {THi+}) or ([[@MV+ & O*n+]]);
surprise.v alarm.v amaze.v amuse.v astonish.v astound.v excite.v depress.v
disgust.v distress.v dismay.v irritate.v embarrass.v annoy.v: 
<verb-s-pl,i> & <vc-surprise>;
surprises.v alarms.v amazes.v amuses.v astonishes.v astounds.v excites.v depresses.v
disgusts.v distresses.v dismays.v irritates.v embarrasses.v annoys.v: 
<verb-s-s> & <vc-surprise>;
surprised.v alarmed.v amazed.v amused.v astonished.v astounded.v excited.v
 depressed.v disgusted.v distressed.v dismayed.v irritated.v embarrassed.v 
annoyed.v: 
(<verb-s-sp,pp> & <vc-surprise>) or <verb-pv> or <verb-po>;
surprising.v alarming.v amazing.v amusing.v astonishing.v astounding.v
 exciting.v depressing.v disgusting.v distressing.v dismaying.v 
embarrassing.v annoying.v: 
<verb-s-pg> & <vc-surprise>;
surprising.g alarming.g amazing.g amusing.g astonishing.g astounding.g 
exciting.g depressing.g disgusting.g distressing.g dismaying.g 
embarrassing.g annoying.g: 
(<vc-surprise> & <verb-ge>) or <verb-ge-d>;

<vc-prove>: 
((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or ((O+ or OX+ or B-) & {@MV+} 
& (TOo+ or [[Pa+]])) or ({@MV+} & (TOf+ or TH+ or Ce+ or RSe+ or Zs- or Pa+));
prove.v: <verb-x-pl,i> & <vc-prove>;
proves.v: <verb-x-s> & <vc-prove>;
proved.v: (<verb-x-sp,pp> & <vc-prove>) or (<verb-s-pv> & {THi+ or TOf+}) or 
({@E-} & A+) or ({{@MV+} & Pa+} & <verb-po>);
proven.v: (<verb-x-pp> & <vc-prove>) or (<verb-s-pv> & {THi+ or TOf+ or Pa+}) 
or ({@E-} & A+) or ({{@MV+} & Pa+} & <verb-po>);
proving.g: (<vc-prove> & <verb-ge>) or <verb-ge-d>;
proving.v: <verb-x-pg> &  <vc-prove>;

<vc-suggest>: ((O+ or B- or [[@MV+ & O*n+]]) & {@MV+}) or ({@MV+} & 
(Pg+ or TH+ or Ce+ or RSe+ or Zs- or TS+ or ((SI*j+ or SFI**j+) & I*j+)));
suggest.v recommend.v: <verb-pl,i> & <vc-suggest>;
suggests.v recommends.v: <verb-s> & <vc-suggest>;
suggested.v recommended.v: (<verb-sp,pp> & <vc-suggest>) or 
(<verb-s-pv> & {THi+ or TSi+}) or ({@E-} & A+) or <verb-po>;
suggesting.g recommending.g: (<vc-suggest> & <verb-ge>) or <verb-ge-d>; 
suggesting.v recommending.v: <verb-pg> & <vc-suggest>;

<vc-deny>: (((O+ & {{[[@MV+]]} & O*n+}) or (B- & {O+}) or [[@MV+ & O*n+]]) 
& {@MV+}) or ({@MV+} & (Pg+ or TH+ or Ce+ or RSe+));
deny.v: <verb-pl,i> & <vc-deny>;
denies.v: <verb-s> & <vc-deny>;
denied.v: (<verb-sp,pp> & <vc-deny>) or (<verb-pv-b> & {O+ or B- or 
[[@MV+ & O*n+]]} & {@MV+}) or ({O+ or ([[@MV+ & O*n+]])} & <verb-po>);
denying.g: (<vc-deny> & <verb-ge>) or <verb-ge-d>;
denying.v: <verb-pg> & <vc-deny>;

<vc-describe>: ((O+ or B-) & {@MV+} & {AZ+}) or ({@MV+} & (QI+ or Z-))
or ([[@MV+ & O*n+ & {@MV+}]]);
describe.v: <verb-pl,i> & <vc-describe>;
describes.v: <verb-s> & <vc-describe>;
described.v: (<verb-sp,pp> & <vc-describe>) or (<verb-pv> & {AZ+ or Z-}) or 
({@E-} & A+) or ({@MV+} & {AZ+} & <verb-po>);
describing.g: (<vc-describe> & <verb-ge>) or <verb-ge-d>;
describing.v: <verb-pg> & <vc-describe>;

<vc-portray>: ((O+ or B-) & {@MV+} & {AZ+}) or ([[@MV+ & O*n+ & {@MV+}]]);
portray.v depict.v regard.v view.v characterize.v: <verb-pl,i> & <vc-portray>;
portrays.v depicts.v regards.v views.v characterizes.v: <verb-s> & <vc-portray>;
portrayed.v depicted.v regarded.v viewed.v characterized.v: 
(<verb-sp,pp> & <vc-portray>) 
or (<verb-pv> & {AZ+}) or ({@E-} & A+) or ({@MV+} & {AZ+} & <verb-po>);
portraying.g depicting.g regarding.g viewing.g characterizing.g: 
(<vc-portray> & <verb-ge>) or <verb-ge-d>;
portraying.v depicting.v regarding.v viewing.v characterizing.v: 
<verb-pg> & <vc-portray>;

%IDIOMATIC VERBS

do_so take_place show_up take_office do_battle give_way make_way
take_part catch_up catch_on file_suit pick_up take_off break_free
take_over jump_ship see_fit take_note: <verb-pl,i> & <vc-intrans>;
does_so takes_place shows_up pleads_guilty pleads_innocent
takes_office does_battle gives_way makes_way takes_part catches_up
catches_on files_suit picks_up takes_off breaks_free takes_over
jumps_ship sees_fit lets_go takes_note comes_true comes_clean
comes_of_age: 			
<verb-s> & <vc-intrans>;
showed_up pleaded_guilty pleaded_innocent made_way caught_up caught_on
filed_suit picked_up jumped_ship:  
<verb-sp,pp> & <vc-intrans>;
plead_guilty plead_innocent: (<verb-pl,i> or <verb-sp,pp>) & <vc-intrans>;
let_go: ((<verb-pl,i> or <verb-sp,pp>) & <vc-intrans>) or <verb-pv>;
did_so took_place took_office did_battle gave_way took_part took_off
broke_free took_over saw_fit took_note came_true came_clean came_of_age: 
<verb-sp> & <vc-intrans>;
done_so taken_place shown_up taken_office done_battle given_way
taken_part taken_off broken_free taken_over seen_fit taken_note: 
<verb-pp> & <vc-intrans>;
come_true come_clean come_of_age: (<verb-pl,i> or <verb-pp>) & <vc-intrans>;
doing_so taking_place showing_up pleading_guilty pleading_innocent
taking_office
doing_battle giving_way making_way taking_part catching_up catching_on
filing_suit picking_up taking_off breaking_free taking_over jumping_ship
seeing_fit letting_go taking_note coming_true coming_clean coming_of_age: 
(<vc-intrans> & <verb-pg,ge>) or <verb-ge-d>;

<vc-put-up-with>: (O+ or B- or [[@MV+ & O*n+]]) & {@MV+};
allow_for bring_about get_rid_of let_go_of take_note_of: <verb-pl,i> & <vc-trans>; 
puts_up_with allows_for brings_about gets_rid_of lets_go_of
takes_note_of: <verb-s> & <vc-trans>;
put_up_with let_go_of: (<verb-pl,i> or <verb-sp,pp>) & <vc-trans>;
allowed_for brought_about got_rid_of took_note_of: <verb-sp,pp> & <vc-trans>;
gotten_rid_of taken_note_of: <verb-pp> & <vc-trans>;  
putting_up_with allowing_for bringing_about getting_rid_of letting_go_of
taking_note_of: (<vc-trans> & (<verb-ge> or <verb-pg>)) or <verb-ge-d>;

<vc-take-it>: {[@MV+]} & TH+;
take_it make_out point_out give_notice serve_notice: <verb-pl,i> & <vc-take-it>;
takes_it makes_out points_out gives_notice serves_notice: <verb-s> & <vc-take-it>;
 made_out pointed_out served_notice: 
(<verb-sp,pp> & <vc-take-it>) or <verb-pv> or <verb-po>;
took_it gave_notice: <verb-sp> & <vc-take-it>;
taken_it given_notice: <verb-pp> & <vc-take-it>;
taking_it making_out pointing_out giving_notice serving_notice: 
(<vc-take-it> & <verb-pg,ge>) or <verb-ge-d>;

<vc-turn-out>: {[@MV+]} & THi+;
turn_out: <verb-s-pl,i> & <vc-turn-out>;
turns_out: <verb-s-s> & <vc-turn-out>;
turned_out: <verb-s-sp,pp> & <vc-turn-out>;
turning_out: <verb-s-pg> & <vc-turn-out>;

<vc-find-out>: {[@MV+]} & (TH+ or QI+ or Ce+);
find_out figure_out: <verb-pl,i> & <vc-find-out>;
finds_out figures_out: <verb-s> & <vc-find-out>;
found_out figured_out: (<verb-sp,pp> & <vc-find-out>) or <verb-pv> or 
<verb-po>;
finding_out figuring_out: (<vc-find-out> & <verb-pg,ge>) or
<verb-ge-d>; 

<vc-keep-on>: {Pg+ or @MV+};
keep_on give_up go_around: <verb-s-pl,i> & <vc-keep-on>;
keeps_on gives_up goes_around: <verb-s-s> & <vc-keep-on>;
kept_on: <verb-s-sp,pp> & <vc-keep-on>;
gave_up went_around: <verb-s-sp> & <vc-keep-on>;
given_up gone_around: <verb-s-pp> & <vc-keep-on>;
keeping_on giving_up going_around: (<vc-keep-on> & <verb-pg,ge>) or <verb-ge-d>;

<vc-end-up>: Pg+ or Pa+ or ({AF-} & {@MV+});
end_up: <verb-s-pl,i> & <vc-end-up>;
ends_up: <verb-s-s> & <vc-end-up>;
ended_up: <verb-s-sp,pp> & <vc-end-up>;
ending_up: (<vc-end-up> & <verb-pg,ge>) or <verb-ge-d>;

/en/words/words.v.1.p: <verb-pv> or <verb-po>; % two-word passives

<vc-paraph>: 
{@MV+} & (((Xd- or Xq-) & (Xc+ or [[[()]]]) & (COq+ or (CP- & {CC+}) or Eq+)) 
or [(Xc+ or Xe+) & Ce+]);
<vc-paraph-inv>:
{@MV+} & (((Xd- or Xq-) & (Xc+ or [[[()]]]) & (COq+ or (CPx- & {CC+}) or Eq+)) 
or [(Xc+ or Xe+) & Ce+]);
<vc-it-paraph>: {@MV+} & (Xd- or Xq-) & (Xc+ or [[[()]]]) & (COqi+ or 
(CPi- & {CC+}) or Eqi+);

% paraphrasing verbs like "say", "reply"
/en/words/words.v.10.1: [[{@E-} & (((Sp- or I-) & <vc-paraph>) or (SIpj+ & <vc-paraph-inv>))]];
/en/words/words.v.10.2: [[{@E-} & ((Ss- & <vc-paraph>) or (SIsj+ & <vc-paraph-inv>))]];
/en/words/words.v.10.3: 
{@E-} & (((S- or PP-) & <vc-paraph>) or (SI*j+ & <vc-paraph-inv>)
or [[Pvf- & <vc-it-paraph>]]);
read.q: {@E-} & (((S- or I- or PP-) & <vc-paraph>) or (SI*j+ & <vc-paraph-inv>));
wrote.q: {@E-} & ((S- & <vc-paraph>) or (SI*j+ & <vc-paraph-inv>));
written.q: {@E-} & PP- & <vc-paraph>;
/en/words/words.v.10.4: [[{@E-} & Pg- & <vc-paraph>]];

seem.i appear.i: [[{@E-} & (SFp- or If-) & <vc-it-paraph>]];
seems.i appears.i: [[{@E-} & SFs- & <vc-it-paraph>]];
seemed.i appeared.i: {@E-} & (SF- or PPf-) & <vc-it-paraph>;
seeming.i appearing.i: [[{@E-} & Pgf- & <vc-it-paraph>]];

say.q: {@E-} & (((Sp- or I-) & <vc-paraph>) or (SIpj+ & <vc-paraph-inv>));
says.q: {@E-} & ((Ss- & <vc-paraph>) or (SIsj+ & <vc-paraph-inv>));
said.q: {@E-} & (((S- or PP-) & <vc-paraph>) or (SI*j+ & <vc-paraph-inv>));
saying.q: {@E-} & Pg- & <vc-paraph>;

tell.q: [[{@E-} & (Sp- or I- or SIpj+) & O+ & <vc-paraph>]];
tells.q: [[{@E-} & (Ss- or SIsj+) & O+ & <vc-paraph>]];
told.q: {@E-} & (((S- or PP- or SI*j+) & O+) or Pv-) & <vc-paraph>;
telling.q: [[{@E-} & Pg- & O+ & <vc-paraph>]];

ask.q: [[{@E-} & (((Sp- or I-) & {O+}) or SIpj+) & <vc-paraph>]];
asks.q: [[{@E-} & ((Ss- & {O+}) or SIsj+) & <vc-paraph>]];
asked.q: {@E-} & (((S- or PP-) & {O+}) or Pv- or SI*j+) & <vc-paraph>;
asking.q: [[{@E-} & Pg- & {O+} & <vc-paraph>]];

<vc-vote>: Vv+ & {@MV+};
say.i vote.i: <verb-pl,i> & <vc-vote>;
says.i votes.i: <verb-s> & <vc-vote>;
said.i voted.i: <verb-sp,pp> & <vc-vote>;
saying.i voting.i: 
(<vc-vote> & <verb-pg,ge>);
yes no.i: Vv-;

double.v triple.v quadruple.v quintuple.v:
{EN-} & <verb-pl,i> & <vc-fill>;
doubles.v triples.v quadruples.v quintuples.v:
{EN-} & <verb-s> & <vc-fill>;
doubled.v tripled.v quadrupled.v quintupled.v:
{EN-} & ((<verb-sp,pp> & <vc-fill>) or <verb-pv> or ({@E-} & A+) or <verb-po>);
doubling.v tripling.v quadrupling.v quintupling.v:
{EN-} & (<verb-pg> & <vc-fill>);
doubling.g tripling.g quadrupling.g quintupling.g:
{EN-} & ((<vc-fill> & <verb-ge>) or ({@E-} & A+) or <verb-ge-d>);

%PREPOSITIONS

<prep-main-a>: [Mp-] or MVp- or [({Xc+ & {Xd-}} & CO+)] or Pp- or
(Xd- & Xc+ & (MX*x- or MVx-)) or (Cs+ & (Mj- or (Xd- & Xc+ & MX*j-)))
or (Wj- & Qd+) or [Wq- & PF+];
<prep-main-b>: [Mp-] or Pp- or MVp- or [({Xc+ & {Xd-}} & CO+)] or 
(Xd- & Xc+ & (MX*x- or MVx-));
<prep-main-t>: [Mpn-] or Pp- or MVpn- or [({Xc+ & {Xd-}} & CO*n+)] or 
(Xd- & Xc+ & (MX- or MVx-));
<prep-main-e>: [Mp-] or Pp- or MVa- or [({Xc+ & {Xd-}} & CO+)] or 
(Xd- & Xc+ & (MX*x- or MVx-));

under beneath:
({Yd-} & {JQ+} & J+ & (<prep-main-a> or FM-)) or (MVp- & B-);
below above behind.p: ({Yd-} & {{JQ+} & J+} & (<prep-main-a> or FM-)) or (MVp- & B-);
within: ({JQ+} & J+ & <prep-main-a>) or (MVp- & B-);
during: ({JQ+} & J+ & (<prep-main-a> or UN-)) or (MVp- & B-);
from:
({Yd-} & {JQ+} & (FM+ or J+ or Mgp+) & <prep-main-a>)
or (MVp- & B-) or (NIa+ & NIb+ & NIc+);
at toward towards without upon:
({JQ+} & (J+ or Mgp+) & <prep-main-a>) or (MVp- & B-);
except: ({JQ+} & (J+ or Mgp+) & <prep-main-a>) or (MVp- & B-) or 
((MVp+ or TO+) & <prep-main-a>); 
against beyond beside: 
({JQ+} & (J+ or Mgp+) & <prep-main-a>) or (MVp- & B-);
between:
({JQ+} & (J+ or Mgp+) & <prep-main-a>) or (MVp- & B-) or (NIa+ & NId+ & NIc+);
with: ({JQ+} & (J+ or Mgp+) & <prep-main-a>)
or (J+ & {EBm+} & ([P+] or [[O*n+]]) & ([({Xc+ & {Xd-}} & CO+)] or 
MVp- or (Xd- & Xc+ & (MX*x- or MVx-)))) 
or (MVp- & B-);
among:
({JQ+} & (J+ or Mgp+) & (<prep-main-a> or FM-)) or (MVp- & B-);
for.p: ({JQ+} & (J+ or Mgp+ or TI+) & 
<prep-main-a>) or (MVp- & B-) or (MG- & JG+) or (MVp- & FL+);

into: ({JQ+} & (J+ or Mgp+ or QI+) & <prep-main-a>) or (MVp- & B-);
about: ({JQ+} & (J+ or Mgp+ or QI+) & <prep-main-a>) or EN+ or EZ+ or 
(MVp- & B-) or (TOf+ & (Mp- or MVp- or Pp-));

off across along through: 
({JQ+} & J+ & (<prep-main-a> or FM-)) or K- or (MVp- & B-);
past.p: 
({Yd-} & {JQ+} & J+ & (<prep-main-a> or FM-)) or K- or (MVp- & B-);
around:
({JQ+} & (J+ or Mgp+) & (<prep-main-a> or FM-)) or K- or (MVp- & B-)
or [EN+];
out up down.e:
({Yd-} & {JQ+} & ([J+] or [[MVp+]]) & (({Xd- & Xc+} & MVa-) or FM-)) or K- 
or (MVp- & B-);
by: ({JQ+} & (J+ or Mgp+ or JT+) & (<prep-main-a> or FM-)) or K- or
 (MVp- & B-);
in: ({JQ+} & (J+ or Mgp+ or IN+) & (<prep-main-a> or FM-)) 
or K- or (MVp- & B-) or (MG- & JG+);

on: ({JQ+} & (J+ or Mgp+ or ON+ or [QI+]) & <prep-main-a>) or K- or 
(MVp- & B-);
over: ({Yd-} & {JQ+} & (J+ or Mgp+ or QI+ or [[MVp+]]) & (<prep-main-a> or FM-)) 
or K- or EN+ or (MVp- & B-);
just_over just_under well_over: EN+;
like.p: ({[EA-]} & (((J+ or Mgp+ or [[Mp+ or MVs+]]) & <prep-main-b>)
or (Vf- & Mgp+) or (LI- & (J+ or Cs+)))) or (MVp- & B-);
unlike: J+ & (MVp- or Pp- or [({Xc+ & {Xd-}} & CO+)] or 
(Xd- & Xc+ & (E+ or MVx-)));
of: ({JQ+} & (J+ or Mgp+ or QI+) & (Mp- or OF- or (Xd- & Xc+ & MX*x-) 
or (Cs+ & (Mj- or (Xd- & Xc+ & MX*j-))) or [[({Xc+ & {Xd-}} & CO+)]]))
or ((OF- or Mp-) & B-) or (MG- & JG+) or (NF- & NJ+) or (Mp- & TI+); 
of_them: (ND- or MF-) & (J+ or Pa+) & Xd- & (MX*x- or MVx-) & Xc+;

to: ({@E-} & {NT-} & I+ & (TO- or [{Xd- & Xc+} & MVi-] 
or [[R-]] or (SFsx+ & <S-CLAUSE>) or [Xc+ & {Xd-} & CO+]))
or I*a+ or ({JQ+} & (J+ or Mgp+) & <prep-main-a>) 
or [MVp- & B-] or NIb-;
so_as_to: I+ & {Xd- & Xc+} & MVi-; 

besides: {J+ or Mgp+} & ([({Xc+ & {Xd-}} & CO+)] or MVp- or [Wq- & PF+]);
throughout: {J+} & ([({Xc+ & {Xd-}} & CO+)] or MVp- or [Wq- & PF+]);

inside.e outside.e underneath alongside:
{J+} & (<prep-main-b> or FM-);
amid plus.p minus.p via onto: 
J+ & (<prep-main-b> or [Wq- & PF+]);
versus: (J+ & Mp-) or (G- & G+);
vs: {Xi+} & G- & G+;

worth.p: (Mp- & (J+ or OF+)) or (Paf- & Mgp+) or (Pa- & (J+ or B-));
opposite.p: J+ & <prep-main-b>;
better_off worse_off: {EC-} & Pa- & {Pg+};

off_of out_of:  ({JQ+} & J+ & <prep-main-b>) or (MVp- & B-);

despite notwithstanding 
other_than apart_from aside_from: (J+ or Mgp+) & (MVp- or (Xd- & Xc+ & 
(MVx- or E+)) or
[({Xc+ & {Xd-}} & CO+)]); 
rather_than: (J+ or Mgp+ or Mp+ or I+) & 
((Xd- & Xc+ & (E+ or MVx-)) or MVp- or [({Xc+ & {Xd-}} & CO+)]); 
instead_of because_of prior_to: 
(J+ or Mgp+) & (MVp- or Pp- or [({Xc+ & {Xd-}} & CO+)] or (Xd- & Xc+ & 
(E+ or MVx-)));
as_well_as: (J+ or Mgp+) & (MG- or Mp- or MVp- or [({Xc+ & {Xd-}} & CO+)] or
(Xd- & Xc+ & (MX*x- or MVx-)));
according_to as_of in_case_of in_response_to unbeknownst_to thanks_to:
J+ & (MVp- or Pp- or [({Xc+ & {Xd-}} & CO+)] or (Xd- & Xc+ & (E+ or MVx-)));
due_to along_with en_route_to in_connection_with: J+ & <prep-main-b>;
regardless_of as_to irrespective_of: (J+ or QI+) & 
(MVp- or [({Xc+ & {Xd-}} & CO+)] or (Xd- & Xc+ & (E+ or MVx-)));

overhead.e midway in_public in_private en_route 
a_la_mode a_la_carte side_by_side from_coast_to_coast: <prep-main-b>;
abroad upstairs.e downstairs.e overseas.e next_door: 
<prep-main-b> or FM-;
elsewhere: <prep-main-b> or FM- or [[J-]];
ahead at_hand in_store in_reverse in_place in_town 
under_way in_office out_of_office out_of_reach
in_reach within_reach on_guard at_large in_hand on_hand for_free
on_file in_line on_line in_loco_parentis on_board en_route in_bed 
out_of_bed on_strike on_top from_afar at_stake in_question
at_issue on_lease on_trial in_league in_cahoots in_front in_back
on_break on_camera in_command in_concert by_association in_association
on_deck on_disk on_file on_foot on_location on_line online.e:
MVp- or Mp- or Pp- or (Xc+ & Xd- & (MX*x- or MVx-)); 
uptown downtown.e underground.e out_of_town: 
MVp- or Mp- or Pp- or FM- or (Xc+ & Xd- & MVx-);

forward.e backward forwards.e backwards sideways ashore abreast aft
half-way two-fold downhill southward underfoot westward eastward
northward overnight.e on_hold on_track in_situ in_toto off_balance
in_check on_course off_course under_oath at_end by_example on_holiday
by_invitation on_patrol on_stage in_step in_tempo on_schedule
behind_schedule ahead_of_schedule for_good for_keeps in_phase
out_of_step out_of_phase in_tune out_of_tune in_session out_of_session
in_phase neck_and_neck under_contract: MVp- or Pp- or (Xc+ & Xd- &
MVx-);

indoors outdoors upstream downstream underwater.e:
MVp- or Pp- or FM- or (Xc+ & Xd- & MVx-); 
everywhere anywhere: {EL+} & ((Cs+ & (({Xc+ & {Xd-}} & CO+) or 
({Xd- & Xc+} & MVs-))) or (MVp- or Pp- or FM- or (Xc+ & Xd- & MVx-)));
somewhere someplace: {EL+} & (MVp- or Pp- or FM- or [({Xc+ & {Xd-}} & CO+)] 
or (Xc+ & Xd- & MVx-));
nowhere: {EL+} & (MVp- or Pp- or FM- or (Xc+ & Xd- & MVx-)); 

as_usual to_date on_average
in_turn so_far in_particular in_response in_general thus_far in_reply: 
MVp- or Mp- or ({Xc+ & {Xd-}} & CO+) or (Xc+ & Xd- & (MVx- or MX*x-)); 

recently: {EE- or EF+} & (({Xd- & Xc+} & MVp-) or Pp- or E+ or ({Xc+ &
{Xd-}} & CO+) or EB- or JT- or Ca+ or Qe+ or [[Mp-]]); 
now.e: ({Xd- & Xc+} & MVp-) or Pp- or E+ or ({Xc+ & {Xd-}} & CO+) or
EB- or [[Mp-]]; 
then.e: ({Xd- & Xc+} & MVp-) or Pp- or E+ or ({Xc+ &
{Xd-}} & CO+) or EB- or (S+ & Xd- & Xc+ & MVs-) or [[Mp-]];

later earlier: ({ECa- or Yt-} & (E+ or Mp- or Pp- or MVb- 
or [({Xc+ & {Xd-}} & CO+)] or (Xd- & Xc+ & (MX*x- or MVx-))
or ({[[@Ec-]]} & {Xc+} & A+))) or (Yt- & (Ca+ or Qe+));

away: ({Yd-} & (MVp- or Pp- or ({Xc+ & {Xd-}} & CO+))) or K-;
aboard: ((MVp- or Mp- or Pp-) & {J+}) or K-;
apart: {Yd-} & K-; 
home.i: K-;
back.k: ({Yd-} & K-) or (MVp+ & (MVp- or FM-));
forth aside.p: K- or MVa-;

nearby: A+ or MVp- or Pp- or FM-;
next_to in_back_of in_front_of close_to on_top_of outside_of
inside_of atop:
J+ & (<prep-main-b> or FM- or [Wq- & PF+]); 
ahead_of by_way_of akin_to betwixt vis-a-vis in_lieu_of on_account_of
in_place_of in_search_of:
J+ & (<prep-main-b> or [Wq- & PF+]);
near.p: {EE- or EF+} & J+ & (<prep-main-b> or FM- or [Wq- & PF+]);
all_over all_around: {J+} & (Pp- or MVp- or [({Xc+ & {Xd-}} & CO+)] or FM-
or Mp-);
per: Us+ & Mp-;
such_as: J+ & (MVa- or Mp- or (Xc+ & Xd- & (MVx- or MX*x-)));

here: J- or <prep-main-b> or [Wq- & PF+];

there: J- or <prep-main-b> or 
((SFst+ or SFp+) & <CLAUSE>) or SFIst- or SFIp- or OXt-;

de du des del von: {G-} & G+;
y: G- & G+;

% TIME AND PLACE EXPRESSIONS 

this_time that_time these_days: <prep-main-t> or [[E+]];
last_time next_time: 
<prep-main-t> or JT- or YS+ or [[<noun-main-s>]];

day.t week.t month.t year.t weekend.t morning.t afternoon.t evening.t
night.t semester.t term.t season.t session.t:
((DTn- or DTi-) & (<prep-main-t> or [[E+]])) or 
(DTi- & (JT- or [[<noun-main-s>]] or YS+)) or (DTa- & <prep-main-t>);
the_next the_previous the_following this_past: DTn+;

today tonight: <prep-main-t> or JT- or [[E+]]
 or YS+ or [[<noun-main-s>]];
yesterday: {TD+} & (<prep-main-t> or JT- or [[E+]]
 or YS+ or [[<noun-main-s>]]);
tomorrow: {TD+} & (<prep-main-t> or JT- or YS+ or [[<noun-main-s>]]);
Monday Tuesday Wednesday Thursday Friday Saturday Sunday:
((DTn- or DTie- or [()]) & {TD+ or TW+} & 
(YS+ or <prep-main-t> or JT- or ON- or [[<noun-main-s>]])) or [[AN+]];

morning.i afternoon.i night.i evening.i: TD-;
January February March April May.i June July August September October
November December: 
((DTn- or DTie- or ({TA-} & {TY+})) & (JT- or IN- or [[<noun-main-s>]] or YS+))
 or ((DTn- or DTie-) & <prep-main-t>) or
(TM+ & {TY+} & ((Xd- & Xc+ & TW-) or ON- or JT- or 
[[<noun-main-s> or MVp- or Mp- or AN+]])) or AN+;

a.m. p.m.: ND- & {@MX+} & <noun-main-s>; 
Jan.x Feb.x Aug.x Sept.x Oct.x Nov.x Dec.x: 
{Xi+} & TM+ & {TY+} & ((Xd- & Xc+ & TW-) or ON- or JT- or [[<noun-main-s>
or MVpn- or Mp- or AN+]]);

fall.i spring.i winter.i summer.i: 
((DTn- or DTi-) & <prep-main-t>)
or (DTi- & (JT- or YS+ or [[<noun-main-s>]]));

weeks.p days.p hours.p minutes.p seconds.p months.p years.p decades.p
centuries.p semesters.p terms.p nights.p:
((ND- or [[EN-]] or [()]) & (Yt+ or OT-)) or (ND- & Ye-) or (TQ- & BT+);
week.p day.p hour.p minute.p second.p month.p year.p decade.p century.p
semester.p term.p night.p:
(NS- & (({NJ-} & {EN-} & (Yt+ or OT-)) or (EN- & J-))) or
(NSa- & [[Mp- or Ys-]]) or ({NR- or TT-} & DG- & ((Cs+ & (({Xc+ & {Xd-}} & CO+) 
or MVp- or (Xd- & Xc+ & MVx-))) or Yt+)); 
year_and_a_half: NSa- & {EN-} & (Yt+ or OT-);
moment.p: (NS- & (({EN-} & (Yt+ or OT-)) or (EN- & J-))) or 
({NR- or TT-} & DG- & ((Cs+ & (({Xc+ & {Xd-}} & CO+) 
or MVp- or (Xd- & Xc+ & MVx-))) or Yt+)); 
a_while: J- or Yt+ or OT-;
now.i then.i: JT- or FM-;
now_on then_on: FM-;
from_now: Yt- & <prep-main-t>;
a_long_time some_time a_few_moments moments.p: Yt+ or OT-;
ago: Yt- & (<prep-main-e> or Ca+ or Qe+ or JT-);
every.i: {EN-} & Ye+ & <prep-main-t>;
times.i: (ND- & (({Xc+ & {Xd-}} & CO+) or MVp- or EC+ or EZ+
or Ca+ or Qe+)) or (((({ND-} & DG-) & {Cs+}) or (ND- & Ys+)) & 
(({Xc+ & {Xd-}} & CO+) or MVp- or (Xd- & Xc+ & MVx-)));
time.i: {TT- or NR-} & DG- & {Cs+} & (({Xc+ & {Xd-}} & CO+) or MVp-
or (Xd- & Xc+ & MVx-)); 
the_year: TY+ & <noun-main-s>;
every_time: {EN-} & (Cs+ & (({Xc+ & {Xd-}} & CO+) or MVp- or 
(Xd- & Xc+ & MVx-)));

feet.p miles.p yards.p inches.p meters.p blocks.p light-years.p:
(ND- or [()] or [[EN-]]) & (Yd+ or EC+ or [[MVp-]] or Ya+ or OD-);
foot.p mile.p yard.p inch.p block.p light-year.p:
NS- & {NJ-} & {EN-} & (Yd+ or EC+ or [[MVp-]] or Ya+ or OD-);
a_long_way: Yd+;
point.p percentage_point:
(NS- or NIe-) & {NJ-} & (Yd+ or OD-);
points.p percentage_points: ND- & (Yd+ or MVp-);

dollars.i cents.i:  ND- & (EC+ or Yd+ or OD-);
1_dollar one_dollar a_dollar 1_cent 
one_cent a_cent: {NJ-} & (EC+ or Yd+ or OD-);
share.i pound.i ounce.i gallon.i barrel.i head.x: NSa- & Mp-;
dollar.i cent.i: ((ND- or NS- or NIe-) & AN+) or (NS- & {NJ-} & (EC+ or Yd+ or OD-));
twofold threefold fourfold fivefold sixfold sevenfold eightfold ninefold
tenfold a_hundredfold a_thousandfold: MVp- or A+;
degrees_Fahrenheit degrees_Centigrade: ND- & <noun-main-s>;

%QUESTION WORDS & CONJUNCTIONS

who: (R- & (({MVp+ or MVx+} & RS+) or Cr+)) 
or ({EL+} & (S**w+ or B*w+) & (Ws- or Wq- or QI*d- or BIqd-)) or
({MVp+ or MVx+} & (S**w+ or B*w+) & (Xd- & (Xc+ or [[[()]]]) & MX*r-)); 

what: ({EL+} & (D**w+ or Ss*w+ or Bsw+ or BW+) & (Wq- or Ws- or QI*d-
or BIqd-)) or ((Ss*d+ or Bsd+ or BW+) &
(<noun-main2-s> or (Ss*t+ & <CLAUSE>) or SIs*t-)) or (D+ & JQ-);

which: ((Jr- or R-) & (({MVp+ or MVx+} & RS+) or Cr+)) or 
((D**w+ or ({OF+} & (S**w+ or B*w+))) & (Wq- or Ws- or QI*d- or BIqd-))
 or Jw- or (JQ- & D+) or ({MVp+ or MVx+} & (S**w+ or B*w+) & 
((Xc+ or [[[()]]]) & Xd- & MX*r-));

whom: (R- & Cr+) or (B*w+ & (Wq- or QI*d- or BIqd- or ((Xc+ or [[[()]]]) & Xd- & MX*r-)))
 or (Jr- & (RS+ or Cr+)) or Jw-;

whose: (D**w+ & (Mr- or Wq- or Ws- or QI*d- or BIqd- or ((Xc+ or [[[()]]]) & Xd- & MX*d-))) 
or (JQ- & D+) or (U+ & Jr- & (RS+ or Cr+));

whoever: {EL+} & (((Ss*d+ or Bsd+ or [[CX+]]) & 
(<noun-main-s> or (Xc+ & {Xd-} & CO+) or ({Xd- & Xc+} & MVs-)))
or [[(O- or J-) & CX+]]);
whatever: ({EL+} & (((Ss*d+ or Bsd+ or BW+ or D**w+) &
(<noun-main-s> or (Xc+ & {Xd-} & CO+) or ({Xd- & Xc+} & MVs-)))
or [[(O- or J-) & CX+]]))
or ((ALx+ & J+) & (({Xd-} & Xc+ & CO+) or ({Xd- & Xc+} & MVs-)));

whenever wherever however.c: {EL+} & (Cs+ & (({Xc+ & {Xd-}} & CO+) or 
({Xd- & Xc+} & MVs-)));
no_matter: QI+ & ((Xc+ & {Xd-} & CO+) or ({Xd- & Xc+} & MVs-));

that.c: (Cet+ &  
([SFsx+ & <S-CLAUSE>] or TH- or [[MVh-]])) or (TS- & (SI*j+ or SFI**j+) & I*j+);
that.d: [{AL-} & D*u+];
that.r: (R- & (({MVp+ or MVx+} & RS+) or Cr+)) or EE+ or (EA+ & {HA+}) or DTn+;
that.p: {[[M+]]} & <noun-main-h>;

because: (Cs+ & (({Xc+ & {Xd-}} & CO*s+) or BIh- or 
({Xd- & Xc+} & MVs-))) or 
(OF+ & (({Xc+ & {Xd-}} & CO+) or BIh- or ({Xd- & Xc+} & MVa-)));
now_that just_as if_only in_case whereby whereupon insofar_as inasmuch_as 
ere on_the_grounds_that on_grounds_that in_that in_the_event_that in_the_event:
Cs+ & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} & MVs-));
on_condition: (TH+ or TS+) & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} & MVs-));
unless though.c even_though: (Cs+ or Mgp+ or Mv+) & (({Xc+ & {Xd-}} & CO*s+) or 
({Xd- & Xc+} & MVs-) or (Xd- & Xc+ & E+));
as_if as_though: ((Cs+ or Mgp+ or Mv+ or Mp+) & (({Xc+ & {Xd-}} & CO*s+) or 
({Xd- & Xc+} & MVs-) or 
(Xd- & Xc+ & E+))) or ((BIh- or LI-) & Cs+);
as_soon_as: Cs+ & {Xc+ & {Xd-}} & CO*s+;
until: ((Mgp+ or J+ or JT+ or UN+) & (({Xc+ & {Xd-}} & CO+) or 
({Xd- & Xc+} & MVp-) or [Mp-])) or (Cs+ & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} & MVs-)));

since: ((Mgp+ or J+ or JT+ or UN+) & (({Xc+ & {Xd-}} & CO+) or 
({Xd- & Xc+} & MVp-) or [Mp-])) or (Cs+ & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} & MVs-)))
or [[MVa-]] or [[E+]];
ever_since: (J+ or Mgp+ or Cs+) & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} &
 MVs-));
after: {EI- or Yt-} & (((Mgp+ or J+ or JT+) & (<prep-main-b>
or UN- or Ca+ or Qe+)) or (Cs+ & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} &
 MVs-))));
before: ({EI- or Yt-} & (({Mgp+ or J+ or JT+} & (<prep-main-b>
or UN-)) or (Cs+ & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} &
 MVs-))))) or (Yt- & (Ca+ or Qe+));
if: (Cs+ & {Xc+ & {Xd-}} & (Wd- & (Qd+ or Ws+ or Wq+)))
 or ((Cs+ or [Mgp+] or [Mv+]) & (({Xd- & Xc+} & MVs-) or 
({Xc+ & {Xd-}} & CO*s+))) or (QI- & Cs+);
if_possible if_necessary: MVp- or (Xd- & Xc+ & (MVx- or E+)) or 
({Xc+ & {Xd-}} & CO+);
if_so: ({Xc+ & {Xd-}} & CO+);
if_only: ((MVp+ or MVa+ or MVs+) & ({Xd- & Xc+} & MVp-))
or (Wd+ & Wc-);
no_wonder: Wd+ & Wc-;
although: (Cs+ & {Xc+ & {Xd-}} & CO*s+) or ({Xd-} & CC- & Wd+);
while: ((Cs+ or Mgp+ or Mp+) & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} & MVs-) 
or (Xd- & Xc+ & E+)));
once: ({Cs+ or Mp+} & (({Xc+ & {Xd-}} & CO*s+) or ({Xd- & Xc+} & MVs-) or 
(Xd- & Xc+ & E+))) or E+ or EB-;
or: NO+;
but: [(({Xd-} & CC-) or Wc-) & (Wdc+ or Qd+ or Ws+ or Wq+)];
and: [(({Xd-} & CC-) or Wc-) & (Wdc+ or Qd+ or Ws+ or Wq+)] or NId-;
either: (Ds+ or E+ or ({OF+} & <noun-main-x>)) or ({Xd+ & Xc-} 
& MVa-);
neither: Ds+ or E+ or ({OF+} & <noun-main-x>);
nor: ((Xd- & CC-) or Wd-) & Qd+;
for.c: [[(({Xd-} & CC-) or Wc-) & (Wd+ or Qd+ or Ws+ or Wq+)]];
yet.c: ((({Xd-} & CC-) or Wc-) & Wd+) or E+ or MVa- or ({Xd-} & Xc+ & CO+);
thus therefore: ({Xc+ & {Xd-}} & CO+) or ({Xd-} & CC- & Wd+) or 
({Xd- & Xc+} & E+);
when: ((WN- or BIh-) & Cs+) or ((PF+ or TOn+ or Cs+) & (BIq- or 
QI- or (SFsx+ & <S-CLAUSE>))) or (Wq- & (Q+ or PF+)) or 
((Cs+ or Mp+ or Mgp+ or Mv+) & (({Xd- & Xc+} & MVs-) or ({Xc+ & {Xd-}} & CO*s+) 
or (Xd- & Xc+ & E+)));
why: ({EL+} & ((Wq- & Q+) or (QI- & (Cs+ or TOn+)) or (Cs+ & 
((SFsx+ & <S-CLAUSE>) or WY- or BIq-)))) or [[{@CO-} & Wc- & Wi+]];
why_not: [[{@CO-} & Wc- & Wi+]]; 
where: {EL+} & ((Wq- & (WR+ or Q+ or PF+)) or 
((WR+ or Cs+ or TOn+ or PF+) & (BIq- or QI- or (SFsx+ & <S-CLAUSE>)))
 or ((Cs+ or PF+ or WR+) & <prep-main-b>));
whether: (((QI- or BIq-) & (Cs+ or TOn+)) or (Cs+ & SFsx+ & <S-CLAUSE>))
or [[(Cs+ or MV+) & (({Xd- & Xc+} & MVs-) or ({Xc+ & {Xd-}} & CO*s+))]];
whether_or_not: ((QI- or BIq-) & (Cs+ or TOn+)) or 
(Cs+ & (({Xd- & Xc+} & MVs-) or ({Xc+ & {Xd-}} & CO*s+)));
 
how: 
((((EAh+ or EEh+) & {HA+}) or H+ or AFh+) & 
(BIqd- or QI*d- or Wq- or Ws-)) or
(Wq- & (Q+ or AF+)) or 
((Cs+ or TOn+) & (QI- or BIq- or (SFsx+ & <S-CLAUSE>)));

not: EB- or ({@E-} & N-) or NT+ or [[((Ma+ or Mg+ or Mv+ or Mp+) & CO+)
or (Mg- & Mgn+) or (Mv- & Mvn+) or (Mp- & Mp+) or (Ma- & Ma*n+)]];

% We include this, though it's not one of the strippable strings
n't: N- or EB-;

%ADJECTIVES

<adj-op>: [[{@E-} & Wq- & {@MV+} & PF+ & {@MV+} & {CC+}]] or 
({@E-} & {@MV+} & ([[{Xd-} & Xc+ & COp+]] or (Xd- & Xc+ & MX*a-))); 

/en/words/words.adj.1:  % ordinary adjectives
   {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-)
 & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>);

responsible.a accountable.a:
 {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma- 
or Vh-) & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>);

long.a: ({EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or 
Ma-) & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>)) 
or ((Ya- or Yt-) & (Pa- or Ma-)) or (H- & (BT+ or Yt+));

wide.a tall.a deep.a:  ({EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or 
AF+ or Ma-) & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>)) 
or (Ya- & (Pa- or Ma- or <adj-op>));
old.a: ({EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or 
AF+ or Ma-) & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>)) 
or (Ytm- & (Pa- or Ma- or <adj-op>));
aged.i: NIa+ & (Pa- or Max- or <adj-op>);

easy.a hard.a simple.a difficult.a fun.a expensive.a: {EA- or EF+}
& (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) & {@MV+} &
{((TOt+ & B+) or TOi+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TOt+ & B+} & <adj-op>));
ready.a: {EA- or EF+}
& (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) & {@MV+} & 
{((TOt+ & B+) or TO+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TO+ or (TOt+ & B+)} & <adj-op>));
silly.a nasty.a pleasant.a unpleasant.a dangerous.a cruel.a standard.a safe.a
legal.a illegal.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) & 
{@MV+} & {((TOt+ & B+) or TOi+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TOt+ & B+} & <adj-op>));
good.a bad.a unusual.a great.a useful.a a_bitch nice.a
strange.a wonderful.a terrible.a possible.a impossible.a annoying.a 
fair.a unfair.a tough.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) & {@MV+}
& {((TOt+ & B+) or THi+ or TOi+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TOt+ & B+} & <adj-op>));
important.a essential.a crucial.a necessary.a imperative.a vital.a: 
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) &  
(({@MV+} & {(THi+ or TOi+ or TSi+) & {LE+}}) or (TOt+ & B+))) or AA+ or
[[DD- & <noun-main-p>]] or ({TOt+ & B+} & <adj-op>));
common.a practical.a original.a normal.a helpful.a striking.a
confusing.a frustrating.a disturbing.a
logical.a illogical.a elegant.a efficient.a awful.a just.a unjust.a
absurd.a natural.a alarming.a acceptable.a unacceptable.a deplorable.a
detestable.a scary.a shocking.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) & {@MV+}
& {(THi+ or TOi+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>);
surprising.a interesting.a odd.a remarkable.a amazing.a exciting.a depressing.a 
rare.a embarrassing.a: 
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) & 
{@MV+} & {(THi+ or Ci+ or TOi+) & {LE+}}) or AA+ or 
[[DD- & <noun-main-p>]] or <adj-op>);
crazy.a sane.a insane.a stupid.a ridiculous.a wrong.a curious.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) & 
{@MV+} & {(TO+ or TOi+ or THi+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
 or ({TO+} & <adj-op>));
wise.a unwise.a smart.a intelligent.a: {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) 
or ((Paf- or AF+ or 
Ma-) & {@MV+} & {(TO+ or TOi+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TO+} & <adj-op>));
unlikely.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) 
& {@MV+} & {(TOf+ or THi+ or Ci+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TO+} & <adj-op>));
likely.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) 
& {@MV+} & {(TOf+ or THi+ or Ci+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TO+} & <adj-op>) or [E+]);
apparent.a false.a official.a strict.a significant.a funny.a notable.a untrue.a tragic.a
plain.a urgent.a a_drag a_bummer definite.a evident.a impressive.a incredible.a
inevitable.a mysterious.a pathetic.a probable.a admirable.a commendable.a conceivable.a
insignificant.a miraculous.a self-evident.a undeniable.a plausible.a understandable.a
demonstrable.a hilarious.a improbable.a inexcusable.a outrageous.a paradoxical.a shameful.a
inconceivable.a unbelievable.a astonishing.a disgraceful.a debatable.a arguable.a
lamentable.a regrettable.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or
((Paf- or AF+ or Ma-) & {@MV+} & {(THi+ or Ci+) & {LE+}}) or AA+ or 
[[DD- & <noun-main-p>]] or <adj-op>);
clear.a unclear.a relevant.a irrelevant.a obvious.a immaterial.a: {EA- or EF+} & 
(({[[@Ec-]]} & {Xc+} & A+) or
((Paf- or AF+ or Ma-) & {@MV+} & {(THi+ or QIi+) & {LE+}}) or 
AA+ or [[DD- & <noun-main-p>]] or <adj-op>);
clear.i: {EA- or EF+} & Vm- & TH+;
sure.i certain.i: {EA- or EF+} & Vm- & (TH+ or TO+ or (OF+ & {@MV+}));
tactful.a conventional.a advisable.a prudent.a sensible.a tactless.a polite.a
impolite.a arrogant.a conceited.a obnoxious.a valuable.a reasonable.a
unreasonable.a traditional.a unnecessary.a tempting.a usual.a
inadvisable.a lovely.a a_mistake ethical.a unethical.a immoral.a childish.a awkward.a
appropriate.a costly.a customary.a desirable.a dumb.a effective.a fashionable.a 
foolish.a healthy.a hip.a okay.a OK.a ok.a
painful.a selfish.a sufficient.a advantageous.a boring.a
inappropriate.a insufficient.a irrational.a irresponsible.a mandatory.a meaningless.a
preferable.a senseless.a trivial.a wrongheaded.a premature.a risky.a dishonest.a
hypocritical.a enjoyable.a idiotic.a inconvenient.a unkind.a pointless.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or
((Paf- or AF+ or Ma-) & {@MV+} & {TOi+ & {LE+}}) or AA+ or 
[[DD- & <noun-main-p>]] or <adj-op>);
glad.a fortunate.a unfortunate.a lucky.a unlucky.a happy.a sad.a surprised.a
delighted.a overjoyed.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) & 
{@MV+} & {(Ce+ or TO+ or TH+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]] 
or ({Ce+ or TO+ or TH+} & <adj-op>));
certain.a: {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or 
((Paf- or AF+ or Ma-) &
{@MV+} & {(Ce+ or TOf+ or TH+ or QI+ or (OF+ & {@MV+})) & {LE+}}) or AA+ or 
[[DD- & <noun-main-p>]] or ({Ce+ or TO+ or TH+ or QI+ or OF+} & <adj-op>));
unknown.a questionable.a: 
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Paf- or AF+ or Ma-) 
& {@MV+} & {QIi+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>);
sure.a unsure.a uncertain.a careful.a: {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) 
or ((Pa- or AF+ or Ma- 
) & {@MV+} & {(Ce+ or TO+ or TH+ or QI+ or (OF+ & {@MV+})) & {LE+}}) or AA+
or [[DD- & <noun-main-p>]] or ({Ce+ or TO+ or TH+ or QI+ or OF+} & <adj-op>));
correct.a incorrect.a right.a excited.a 
disappointed.a upset.a sorry.a content.a determined.a
amused.a amazed.a astonished.a astounded.a pleased.a
disgusted.a distressed.a dismayed.a irritated.a embarrassed.a alarmed.a:
 {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) & 
{@MV+} & {(TO+ or TH+) & {LE+}}) or AA+ or [[DD- & <noun-main-p>]]
or ({TO+ or TH+} & <adj-op>));
proud.a scared.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) & 
{@MV+} & {(TO+ or TH+ or (OF+ & {@MV+})) & {LE+}}) or AA+ or [[DD- & 
<noun-main-p>]] or ({TO+ or TH+ or OF+} & <adj-op>));
tired.a full.a sick.a critical.a guilty.a typical.a
capable.a contemptuous.a incapable.a reminiscent.a scornful.a mindful.a short.a
appreciative.a complimentary.a born.a worthy.a free.a terrified.a unworthy.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or 
((Pa- or AF+ or Ma-) & {@MV+} & {OF+ & {@MV+}}) or AA+ or 
[[DD- & <noun-main-p>]] or ({OF+ & {@MV+}} & <adj-op>));
fond.a: {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or 
((Pa- or AF+ or Ma-) & OF+ & {@MV+}) or (OF+ & <adj-op>));
afraid.a ashamed.a unafraid.a unashamed.a: {EA- or EF+} & (((Pa- or AF+ or Ma-) & 
{@MV+} & {((OF+ & {@MV+}) or Ce+ or TH+ or TO+) & {LE+}}) or 
({OF+ or Ce+ or TH+ or TO+} & <adj-op>));
apprehensive.a secure.a optimistic.a pessimistic.a annoyed.a confused.a offended.a
insulted.a concerned.a depressed.a doubtful.a 
grateful.a mad.a mistaken.a hopeful.a unhappy.a: 
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) 
& {@MV+} & {TH+ & {LE+}}) or AA+ or [[DD- & <noun-main-p>]] or ({TH+} & 
<adj-op>));
aware.a unaware.a:
{EA- or EF+} & (((Pa- or AF+ or Ma-) & {@MV+} & {(TH+ or (OF+ & {@MV+})) &
{LE+}}) or ({TH+ or OF+} & <adj-op>) or [[DD- & <noun-main-p>]]);
true.a conscious.a confident.a skeptical.a jealous.a suspicious.a envious.a desirous.a
convinced.a unconvinced.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) 
& {@MV+} & {(TH+ or (OF+ & {@MV+})) & {LE+}}) or AA+ or 
[[DD- & <noun-main-p>]] or ({TH+ or OF+} & <adj-op>));
eager.a reluctant.a able.a unable.a impatient.a eligible.a brave.a anxious.a apt.a desperate
keen.a prepared.a willing.a hesitant.a:
{EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Ma-) & 
{@MV+} & {TO+ & {LE+}}) or AA+ or [[DD- & <noun-main-p>]] or 
({TO+} & <adj-op>));

former.a: A+ or G+ or (DG- & <noun-main-x>);
latter.a: DG- & <noun-main-x>;
overall.a onetime.a outboard.a pinstripe.a goddam.a de_facto de_jure erstwhile.a
foster.a outright.a online.a: A+;
pro_forma ad_hoc bona_fide: A+ or Pa-;
a_priori a_posteriori: A+ or MVa- or ({Xc+ & {Xd-}} & CO+);
asleep.a awake.a alike.a alive.a ablaze.a adrift.a afire.a aflame.a afloat.a afoot.a
aghast.a aglow.a agog.a ajar.a amiss.a askew.a astir.a awash.a awry.a de_rigeur
rife.a fraught.a lacking.a: 
((Ma- or Pa-) & {@MV+}) or <adj-op>;
alone.a: ((Ma- or Pa-) & {@MV+}) or <adj-op> or MVp- or E+;

outstanding.a available.a:
   {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or Max-)
 & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>);
due.i effective.i: (TY+ or JT+) & <prep-main-b>;

north.a south.a east.a west.a northeast.a northwest.a southeast.a southwest.a: 
A+ or ({Yd-} & {OF+} & (Pp- or MVp- or Mp- or (Xc+ & Xd- & (MVx- or MX*x-)))) 
or [[DD- & <noun-main-p>]];
northern.a southern.a eastern.a western.a northeastern.a northwestern.a southeastern.a 
southwestern.a: A+ or G+;

%COMPARATIVES AND SUPERLATIVES

more: ({ECa-} & (EAm+ or EEm+ or [MVm-] or [EB*m-] or Qe+ or Ca+)) or
({OF+} & (({ECn-} & (Dmum+ or (Ss+ & <CLAUSE>) or Bsm+)) or 
({ECx- or ND-} & (Dmcm+ or (Sp+ & <CLAUSE>) or Bpm+)) or 
({ECn- or ECx- or ND-} & (Om- or Jm- or (Xd- & MVt+ & Xc+ & MX*m-))))) or
(DG- & (({MVa+} & Cs+) or B+ or Dm*w+ or EA+) & (ER- or (Wd- & Xc+ & ER+)));
more_of_a more_of_an: Ds*m+;
less: ({ECn-} & (Dmum+ or Om- or Jm- or (Ss+ & <CLAUSE>) or Bsm+)) 
or ({ECa-} & (EAm+ or EEm+ or [MVm-] or [EB*m-])) or 
(DG- & (({MVa+} & Cs+) or B+ or Dm*w+ or EA+) & (ER- or (Wd- & Xc+ & ER+)));
fewer: ({ECn-} & (Dmcm+ or Om- or Jm- or (Sp+ & <CLAUSE>))) 
or (DG- & Dm*w+ & (ER- or (Wd- & Xc+ & ER+)));
farther: ({ECa-} & {K+} & (MVb- or Qe+ or Ca+)) or A+;
further.e: ({ECa-} & {K+} & (MVb- or Qe+ or Ca+)) or A+ or E+
or ({Xd-} & Xc+ & CO+);

as.y: {EZ-} & ((EAy+ & {HA+}) or EEy+ or AM+);
as.z: 
(MVz- & (((O*c+ or S**c+ or ({SFsic+} & Zc+)) & {Mp+}) or Mpc+ or Cc+))
or (MVzo- & Bc+ & {U+}) or (MVzp- & (CX+ or CQ+)) or (MVza- & ((AFd+ & {Pa+})
 or PFc+));
as.p: ((J+ or Mp+ or TI+ or ({SFsic+} & Zs+)) & 
(({Xc+ & {Xd-}} & CO+) or ({Xd- & Xc+} & MVp-))) or 
(Cs+ & (({Xc+ & {Xd-}} & CO+) or ({Xd- & Xc+} & MVs-))) or
((J+ or Mp+ or BIt+) & ([Mp-] or (Xd- & Xc+ & MX*x-))) or 
(AZ- & Pa+) or [[(PFc+ or CQ+) & ({Xd- & Xc+} & MVs-)]];
as_possible: MVz-;
as_expected as_reported as_imagined as_suspected as_anticipated as_predicted
as_realized as_proposed as_intended as_supposed: MVz- or 
(({Xc+ & {Xd-}} & CO+) or ({Xd- & Xc+} & MVs-));

much:
({EE-} & (MVa- or ECa+ or Ca+ or Qe+)) or ({EEx- or H-} & (ECn+ or Dmu+ or 
(<noun-sub-s> & (<noun-main-s> or Bsm+)))) or 
(AM- & (Dmuy+ or MVy- or Oy- or Jy- or EB*y-));
slightly somewhat: EC+ or EA+ or MVa- or Em+;
far.c infinitely: EC+;
significantly substantially: {EE- or EF+} & 
(EC+ or E+ or MVa- or ({Xc+ & {Xd-}} & CO+));

/en/words/words.adj.2: % comparative adjectives
({ECa-} & (((Pam- or Mam- or AFm+) & {@MV+}) or ({[[@Ec-]]} & {Xc+} & Am+)))
 or 
(DG- & (TR+ or AF+) & {@MV+} & (ER- or (Wd- & Xc+ & ER+)));
easier.a: ({ECa-} & (({[[@Ec-]]} & {Xc+} & Am+) or ((Pafm- or AFm+ or Mam-) 
& {@MV+} & {((TOt+ & B+) or TOi+) & {LE+}}))) or 
(DG- & (TR+ or AF+) & {@MV+} & {(TOt+ & B+) or TOi+} & (ER- or (Wd- & Xc+ &
 ER+)));
harder.a: ({ECa-} & (({[[@Ec-]]} & {Xc+} & Am+) or ((Pafm- or AFm+ or Mam-)  
& {@MV+} & {((TOt+ & B+) or TOi+) & {LE+}}) or
 MVb-)) or (DG- & (TR+ or AF+) & {@MV+} & {(TOt+ & B+) or TOi+} & 
(ER- or (Wd- & Xc+ & ER+)));
higher.a deeper.a lower.a faster.a:
({ECa-} & (((Pam- or AFm+ or Mam-) & {@MV+}) or ({[[@Ec-]]} & {Xc+} & Am+) 
or MVb- or Qe+ or Ca+)) or
(DG- & (TR+ or AF+ or Cs+) & {@MV+} & (ER- or (Wd- & Xc+ & ER+)));
sooner.a:
({ECa- or Yt-} & (((Pam- or AFm+ or Mam-) & {@MV+}) or ({[[@Ec-]]} & {Xc+} & Am+) 
or MVb- or Qe+ or Ca+)) or
(DG- & (TR+ or AF+ or Cs+) & {@MV+} & (ER- or (Wd- & Xc+ & ER+)));
longer.a: ({ECa- or Yt-} & (((Pam- or AFm+ or Mam-) & {@MV+}) or 
({[[@Ec-]]} & {Xc+} & Am+) or MVb- or Qe+ or Ca+ or OT- or FL-)) or
(DG- & (TR+ or AF+ or Cs+) & {@MV+} & (ER- or (Wd- & Xc+ & ER+)));
smarter.a nicer.a worse.a:
({ECa-} & (({[[@Ec-]]} & {Xc+} & Am+) or ((Pafm- or AFm+ or Mam-) & 
{@MV+} & {(TOi+ or THi+) & {LE+}}))) or
(DG- & (TR+ or AF+) & {@MV+} & {TOi+ or THi+} & (ER- or (Wd- & Xc+ & ER+)));
better.a: 
({ECa-} & (({[[@Ec-]]} & {Xc+} & Am+) or ((Pafm- or AFm+ or Mam-) 
& {@MV+} & {(TOi+ or THi+) & {LE+}}) or MVb- or E+ or Qe+ or Ca+)) or
(DG- & (TR+ or AF+) & {@MV+} & {TOi+ or THi+} & (ER- or (Wd- & Xc+ & ER+)));
different.a: {ECa- or EA- or EF+} & 
(({[[@Ec-]]} & {Xc+} & Am+) or ((Pafm- or AFm+ or Mam-)
 & {@MV+}) or AA+ or [[DD- & <noun-main-p>]] or <adj-op>);

than: (MVt- & (((O*c+ or ({SFsic+} & Zc+) or U*c+) & {Mp+})
 or Mpc+ or S**c+ or MVat+ or MVpt+ or Cc+ or Pafc+))
or ((MVta- or LE-) & ((AFd+ & {Pa+}) or PFc+)) or 
((MVti- or LEi-) & AFdi+ & {Pa+}) or
(((LE- & {AFd+}) or (LEi- & {AFdi+})) & (THc+ or TOic+ or TOfc+ or
(TOtc+ & B+))) 
or (((MVto- & Bc+ & {U+}) or (MVtp- & (CX+ or CQ+))) & {Mp+});

than_expected than_imagined than_proposed than_suspected than_realized 
than_intended than_supposed than_reported than_ever: MVt-;
	
more_than no_more_than fewer_than less_than as_many_as an_estimated 
an_additional up_to as_much_as no_fewer_than no_less_than: EN+;
at_least: EN+ or CO+ or [[{Xd- & Xc+} & MVa-]] or EB-;
all_but: EN+ or E+;

/en/words/words.adj.3: % superlative adjectives
({Xc+} & {NR-} & {[[@Ec-]]} & La-) or 
({NR- or ND-} & DD- & <noun-sub-x> & {TOn+} & <noun-main-x>);
sole.a main.a: {Xc+} & {NR-} & {[[@Ec-]]} & L-;
same.a own.a: ({Xc+} & {NR-} & {[[@Ec-]]} & La-) or  
(DD- & <noun-sub-x> & {TOn+} & <noun-main-x>);
the_same: {EZ-} & (D**y+ or Oy- or Jy- or MVy-);
next.a: ({Xc+ & {Xd-}} & CO+) or MVp- or DTi+ or NR+ or 
({Xc+} & {[[@Ec-]]} & L-)  
or (DD- & <noun-sub-x> & {TOn+} & <noun-main-x>);
past.a previous.a: ({[[@Ec-]]} & {Xc+} & A+) or L- or (Pa- & {@MV+}); 
following.a remaining.a top.i: L-;
hardest.a easiest.a: ({Xc+} & {NR-} & {[[@Ec-]]} & La-) or  
({NR- or ND-} & DD- & <noun-sub-x> & {TOt+ & B+} & <noun-main-x>);
worst.a longest.a fastest.a furthest.a farthest.a: 
({Xc+} & {NR-} & {[[@Ec-]]} & La-) or 
({NR- or ND-} & DD- & ((<noun-sub-x> & {TOn+} & <noun-main-x>) or MVa-));
best.a: ({Xc+} & {NR-} & {[[@Ec-]]} & La-) or  
({NR- or ND-} & DD- & ((<noun-sub-x> & {TOn+} & <noun-main-x>) or MVa-))
or [[E+]];

%ADVERBS

%ADVERBS WHOSE MAIN USE IS ADJECTIVAL
far_from: EA+;
a_bit a_little_bit: EA+ or EC+ or EE+ or ({Xd- & Xc+} & MVa-);
pretty.e extremely very_very very_very_very exceptionally
notoriously unbelievably incurably extraordinarily
jolly.e mighty.e damn.e exceedingly overly downright plumb
vitally relatively abundantly chronically fabulously frightfully genuinely
humanly incomparably inherently marginally moderately patently
singularly supremely unbearably unmistakably unspeakably
awfully decidedly demonstrably fashionably frighteningly horrifyingly
indescribably intolerably laughably predominantly ridiculously unacceptably
unalterably unarguably undeniably undisputedly unimaginably unpardonably
unreasonably unusually hugely infernally:
EA+ or EE+;
very: EA+ or EE+ or [[La-]];
real.e: [[EA+ or EE+]];
quite: EA+ or EE+ or EZ+ or [[Em+]];
amazingly strangely incredibly: 
EA+ or EE+ or ({Xd- & Xc+} & Em+) or ({Xc+ & {Xd-}} & CO+) or EBm- or 
(Xd- & Xc+ & MVa-);
rather: EA+ or EE+ or Vw- or ({Xc+ & {Xd-}} & CO+);
particularly: EA+ or EE+ or Em+ or EB- or (MVl- & (MVp+ or MVa+ or MVs+));
notably: EB- or EA+ or EE+;
almost nearly: EA+ or EE+ or EN+ or EZ+ or Em+ or EBm-;
just_about: Em+ or EN+ or EZ+ or EA+;
entirely reasonably absolutely altogether highly equally fairly totally
completely terribly:
EA+ or EE+ or ({EE- or EF+} & (({Xd- & Xc+} & MVa-) or Em+ or Qe+ or Ca+)); 
really: EA+ or EE+ or Em+ or EBm-;
surprisingly: EA+ or EE+ or ({Xc+ & {Xd-}} & CO+) or ({Xd- & Xc+} & E+) or
(Xd- & Xc+ & MVa-); 
especially: EA+ or EE+ or EB- or Em+ or (MVl- & (MVp+ or MVa+ or MVs+));
virtually: EA+ or EE+ or EN+ or EZ+ or Em+;
wholly fully critically greatly grossly duly unduly: EA+ or
({EE- or EF+} & (({Xd- & Xc+} & MVa-) or Em+ or Qe+ or Ca+));
seemingly utterly: EA+ or Em+;
barely scarcely hardly merely truly practically: Em+ or EBm- or EA+;
partly largely mostly chiefly simply
purely solely: Em+ or EA+ or EB- or (MVl- & (MVp+ or MVa+ or MVs+));

/en/words/words.adv.3: % adverbs like "biochemically"
 EA+ or ({Xd- & Xc+} & (E+ or MVa-)) or EBm- or ({{Xd-} & Xc+} &
 CO+);
in_part: EB- or (MVl- & (MVp+ or MVa+ or MVs+));

%ADVERBS WHOSE ONLY (MAIN) USE IS POST_VERBAL
far.e: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or Ca+ or Qe+ or Yd+);
okay.e barefoot.e willy-nilly quarterly.e madly outright.e
properly staccato.e legato.e all_the_way all_the_time
anymore aloud upwards downwards upward.e downward.e
inward outward inwards outwards anytime live.e 
wholesale.e anew forever awhile aback afoul afresh aloft amok amuck onstage.e
apiece askance astern asunder inter_alia mutatis_mutandis par_excellence
upside-down.e ab_initio ad_infinitum ad_lib
ad_libitum ad_nauseum en_masse aground astray into_account into_effect
to_market to_bid from_scratch to_office for_office for_good 
at_once to_normal to_bed to_town into_office in_advance to_trial by_lot
in_stride by_credit_card by_ear by_foot in_kind en_masse to_mind in_mind
in_pencil in_pen to_scale for_trial all_right full_time part_time by_proxy: 
({Xd- & Xc+} & MVa-); 
hard.e wrong.e: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or Qe+ or Ca+);
poorly.e: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or Qe+ or Ca+ or [[EA+]]);
early.e late.e: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or TA+ or Qe+ or Ca+);
yet.e: ({Xd- & Xc+} & MVa-) or EBm-;

%ADVERBS USABLE POST-VERBALLY OR PRE-VERBALLY
finely specially literally heavily alternately severely dearly
voluntarily dramatically flatly purposely jointly narrowly 
universally thickly widely: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or Em+ or 
Qe+ or Ca+ or [[EA+]]);
respectively: ({Xd- & Xc+} & MVa-) or ({Xd- & Xc+} & E+);
long.e: E+ or ({EE- or EF+} & (({Xd- & Xc+} & MVa-) or OT- or FL- or Yt+));
daily.e weekly.e monthly.e yearly.e hourly.e
partially: ({Xd- & Xc+} & MVa-) or E+ or EB-;                
exactly: E+ or ({Xd- & Xc+} & MVa-) or EB- or EN+ or EZ+;              
well.e: ({EE- or EF+} & (({Xd- & Xc+} & MVa-) or Qe+ or Ca+ or [E+])) or 
[{EA- or EF+} & (Pa- or AF+)] or Yd+;
roughly approximately: ({EE- or EF+} & (EN+ or EZ+ or ({Xd- & Xc+} & MVa-)
 or E+));
together: ({Xd- & Xc+} & MVa-) or E+ or K- or [Mp-];
definitely: {EE-} & (E+ or EB- or (Xd- & Xc+ & MVa-));
by_far: EB- or E+ or MVa-;

%ADVERBS USABLE POST-VERBALLY, PRE-VERBALLY, OR AS OPENERS
initially already somehow again
once_again nowadays sometimes nevertheless nonetheless at_first
at_best at_present of_late indeed:
({Xd- & Xc+} & MVa-) or E+ or ({Xc+ & {Xd-}} & CO+) or EBm-;           
twice: ({Xd- & Xc+} & MVa-) or E+ or ({Xc+ & {Xd-}} & CO+) or EBm- or 
({EN-} & EZ+);           
hence: (Yt- & ({Xd- & Xc+} & MVa-)) or E+ or ({Xc+ & {Xd-}} & CO+) or EBm-;
otherwise formerly lately: 
({Xd- & Xc+} & MVa-) or E+ or ({Xc+ & {Xd-}} & CO+) or EB-;
also: ({Xd- & Xc+} & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+) or EB-;

gradually sadly broadly clearly
annually characteristically comparatively
confidentially currently fundamentally hypothetically
ironically justifiably momentarily mercifully
nominally ominously periodically precisely realistically
simultaneously subsequently superficially thankfully
unofficially effectively traditionally briefly eventually ultimately
mysteriously naturally oddly plainly truthfully appropriately:
{EE- or EF+} & (({Xd- & Xc+} & (MVa- or E+)) or 
({Xc+ & {Xd-}} & CO+) or EB- or Qe+ or Ca+ or [[EA+]]);
occasionally often specifically generally originally: 
{EE- or EF+} & (({Xd- & Xc+} & (MVa- or E+)) or 
({Xc+ & {Xd-}} & CO+) or EB- or Qe+ or Ca+);
/en/words/words.adv.1:  % ordinary manner adverbs
{EE- or EF+} & (({Xd- & Xc+} & MVa-) or Em+ or ({Xc+ & {Xd-}} & CO+) or Qe+
 or Ca+ or [[EA+]]);
shortly: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or E+ or EI+ or ({Xc+ & {Xd-}}
 & CO+) or Qe+ or Ca+);
immediately: ({Xd- & Xc+} & MVa-) or E+ or EI+ or ({Xc+ & {Xd-}} & CO+);
soon: ({EE- or EF+} & (({Xd- & Xc+} & MVa-) or E+ or EI+ or ({Xc+ & {Xd-}}
 & CO+) or EB- or Qe+ or Ca+)) or ({EA- or EF+} & (Pa- or AF+));

certainly possibly probably:	
{EE-} & (E+ or (Xd- & Xc+ & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+) or EB-);
/en/words/words.adv.2: % ordinary clausal adverbs
E+ or (Xd- & Xc+ & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+) or EBm-;
not_suprisingly:
E+ or (Xd- & Xc+ & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+) or EBm-;
though.e: (Xd- & Xc+ & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+);
still.e presumably undoubtedly evidently apparently usually typically perhaps:
E+ or (Xd- & Xc+ & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+) or EB-;
in_fact of_course in_effect for_example for_instance: 
E+ or (Xd- & Xc+ & (E+ or MVa-)) or ({Xc+ & {Xd-}} & CO+) or EB-;

%ADVERBS USABLE POST_VERBALLY OR AS OPENERS
someday sometime thereafter anyhow anyway overall.e
afterwards afterward lengthwise worldwide.e nationwide.e statewide.e
world-wide.e
nation-wide.e state-wide.e industrywide.e instead prima_facie before_long
by_hand by_car by_plane by_boat by_bus by_train by_phone 
by_telephone in_person at_long_last on_cue
on_arrival by_request in_total in_turn over_and_over later_on for_now
day_by_day day_after_day step_by_step one_by_one for_sure for_certain
even_so more_often_than_not all_of_a_sudden:
({Xd- & Xc+} & MVa-) or ({Xc+ & {Xd-}} & CO+);
high.e deep.e low.e: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or 
({Xc+ & {Xd-}} & CO+) or Ca+ or Qe+);
right.e straight.e: ({EE- or EF+} & (({Xd- & Xc+} & MVa-) or 
({Xc+ & {Xd-}} & CO+) or Qe+ or Ca+)) or (Kx- & Ky+) or (Pp- & Pp+); 
short.e: {Yd- or EE- or EF+} & {OF+} & ({Xd- & Xc+} & MVa-);

%ADVERBS USABLE ONLY PRE-VERBALLY (OR PRE-/OPENER)
hereby thereby newly reputedly: E+;                
rightly: {EE-} & E+;
necessarily no_longer: E+ or EBm-; 
ever: E+ or EBm- or EC+ or MVa-;

never.e always: {EN-} & (E+ or EB-);
seldom rarely.e: {EE-} & (E+ or EB-);

just.e: E+ or EB- or (MVl- & (MVa+ or MVp+ or MVs+)) or EN+ or EZ+;

maybe: CO+;
meantime.e furthermore secondly thirdly
in_brief in_short in_sum in_essence: 
({Xd- & Xc+} & E+) or ({Xc+ & {Xd-}} & CO+); 
mainly primarily: 
E+ or ({Xc+ & {Xd-}} & CO+) or EB- or (MVl- & (MVa+ or MVp+ or MVs+));

only: La- or E+ or EN+ or EB- or (MVl- & (MVp+ or MVa+ or MVs+))
     or MVa- or (Rnx+ & <CLAUSE-E>) or (MVp+ & Wq- & Q+);
never.i at_no_time not_once rarely.i since_when: {MVp+} & Wq- & Q+ & {CC+};
not_since: (J+ or Cs+) & Wq- & Q+ & {CC+};
even.e: E+ or EC+ or EB- or ((MVp+ or MVa+ or MVs+) 
& (MVl- or ({Xc+ & {Xd-}} & CO+))) or (Rnx+ & <CLAUSE-E>);
not_even: Rnx+ & <CLAUSE-E>;

too: {ECa-} & (EA+ or EE+ or ({Xd- & Xc+} & MVa-) or (Xd- & Xc+ & E+));
so: (EAxk+ & {HA+}) or EExk+ or 
((({Xd-} & CC-) or ({Xc+} & Wc-)) & (Wd+ or Qd+ or Ws+ or Wq+)) 
or (Wq- & (PF+ or CQ+));
sufficiently: {EE-} & (EAxk+ or EExk+ or MVak-); 
so_that: Cs+ & {Xd- & Xc+} & MVs-;

please.e: Wi- & I+;


% MISCELLANEOUS WORDS AND PUNCTUATION

etc: {Xi-} & Xd- & Xc+ & (MX- or MVa-);
so_on the_like: (<noun-sub-x> & <noun-main-x>) or ((<verb-i> or
<verb-sp,pp> or <verb-pg,ge> or <verb-pv>) & {@MV+}) or M- or MV-;

er um umm uh oh yeah gee gosh wow ah eh hmm hmmm: NO+;

".": ((Xp- or ({@Xca-} & Xc-)) & RW+) or Xi-;

"!" "?": ((Xp- or ({@Xca-} & Xc-)) & RW+) or ({@Xca-} & Xq+);

",": ({@Xca- or [[[@Xc-]]]} & (({EBx+} & Xd+) or Xc-));

";": {@Xca-} & Xx- & (W+ or Qd+) & {Xx+};

":": ({@Xca-} & ((Xx- & (W+ or J+ or Qd+ or TH+ or TOn+) & {Xx+}) 
or Xe-));

"%": (ND- & {DD-} & <noun-sub-x> & (<noun-main-x>)) or (ND- & (OD- or AN+));

"$" US$ C$: NIax+ & (AN+ or NIay- or [[G+]] or ({EN- or NIc- or [[A- & NSa-]]} & {@MX+} &
(OD- or ({DD-} & {[[@M+]]} & (<noun-main-p> or [[(Ss+ & <CLAUSE>) or 
SIs-]])))));

"&": G- & {Xd- & G-} & G+;

"'": YP- & (({AL-} & {@L+} & (D+ or DD+)) or [[<noun-main-x>]] or DP+);
"'s.p": YS- & (({AL-} & {@L+} & (D+ or DD+)) or [[<noun-main-x>]] or DP+);

"(": {EBx+} & Xd+;
")": {@Xca-} & Xc-;

-- -: [[{@Xca-} & Xx- & (W+ or J+ or Qd+ or TH+ or TO+) & {Xx+}]] or
({@Xca-} & (({EBx+} & Xd+) or Xc-));

foo: F+;

ING-WORDS: (<verb-pg> & <vc-tr,intr>) or (<vc-tr,intr> & <verb-ge>)
or ({@E-} & A+) or <verb-ge>;

ED-WORDS: (<verb-sp,pp> & <vc-tr,intr>) or <verb-pv> or ({@E-} & A+);

S-WORDS.v: <verb-s> & <vc-tr,intr>;

S-WORDS.n: ({@AN-} & {@A- & {[[@AN-]]}} & (({Dmc-} & <noun-sub-p> & 
(<noun-main-p> or Bpm+)) or (YP+ & {Dmc-}) or (GN+ & (DD- or [()])) or Up-)) or [[AN+]];

LY-WORDS: {EE- or EF+} & (({Xd- & Xc+} & MVa-) or Em+ or ({Xc+ & 
{Xd-}} & CO+) or Qe+ or Ca+ or [[EA+]]);

UNKNOWN-WORD.n: ({@AN-} & {@A- & {[[@AN-]]}} & (({D*u-} & <noun-sub-s> & 
(<noun-main-m> or Bsm+))
or (YS+ & {D*u-}) or (GN+ & (DD- or [()])) or U-));
UNKNOWN-WORD.v: {@E-} & (Sp- or (RS- & Bp-) or I- or Wi-) & {B- or O+}
 & {@MV+};
UNKNOWN-WORD.a: {EA- or EF+} & (({[[@Ec-]]} & {Xc+} & A+) or ((Pa- or AF+ or
 Ma-)  & {@MV+}) or AA+ or <adj-op>);

LEFT-WALL: (Wd+ or Wq+ or Ws+ or Wj+ or Wc+ or Wi+ or Qd+) & 
{CP+} & {Xx+} & {RW+ or Xp+};       

RIGHT-WALL: RW- or ({@Xca-} & Xc-);

ANDABLE-CONNECTORS:   % these are the connectors that can be combined by
                      % conjunctions. They are listed alphabetically.
      
A+ & A- & AF- & AN+ & B+ & B- & BI- & C+ & C- & CC+ & CO+ & CO- & D+ &
D- & DD- & DT- & E+ & E- & EA- & G+ & GN+ & GN- & I+ & I- & IN- & J+ &
J- & JT- & K- & L- & M+ & M- & MV- & MV+ & MX- & ND+ & O+ & O- & ON- &
QI+ & QI- & P- & PP- & Q- & R+ & RS- & S+ & S- & SI- & TA- & TD+ & TD-
& TH+ & TH- & TI- & TM- & TO- & TS- & U- & Wd- & Wi- & Wq- & Ws- & Xc+
& Xd- & YP+ & YS+ & Z-;



UNLIMITED-CONNECTORS:    % These are the link-types that are not subject
                         % to the length limit.  Always use "+" for these.
      S+ & CO+ & C+ & Xc+ & MV+ & CC+ & TH+ & W+ & RW+ & Xp+ & Xx+ & CP+
      & SFsx+;

