functrigger.mtr

100*prosent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED 100*prosent_prd ] !>,
    FLAGS.TRIGGER "100*prosent_func" ].

absolutt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED absolutt_prd ] !>,
    FLAGS.TRIGGER "absolutt_func" ].

absurd-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED absurd_prd ] !>,
    FLAGS.TRIGGER "absurd_func" ].

adagio-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED adagio_prd ] !>,
    FLAGS.TRIGGER "adagio_func" ].

adskillig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED adskillig_prd ] !>,
    FLAGS.TRIGGER "adskillig_func" ].

akkurat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED akkurat_prd ] !>,
    FLAGS.TRIGGER "akkurat_func" ].

aktenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aktenfor_prd ] !>,
    FLAGS.TRIGGER "aktenfor_func" ].

aktenfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aktenfra_prd ] !>,
    FLAGS.TRIGGER "aktenfra_func" ].

akter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED akter_prd ] !>,
    FLAGS.TRIGGER "akter_func" ].

akterinn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED akterinn_prd ] !>,
    FLAGS.TRIGGER "akterinn_func" ].

akterover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED akterover_prd ] !>,
    FLAGS.TRIGGER "akterover_func" ].

akterut-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED akterut_prd ] !>,
    FLAGS.TRIGGER "akterut_func" ].

akutt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED akutt_prd ] !>,
    FLAGS.TRIGGER "akutt_func" ].

alarmerende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alarmerende_prd ] !>,
    FLAGS.TRIGGER "alarmerende_func" ].

aldeles*ikke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aldeles*ikke_prd ] !>,
    FLAGS.TRIGGER "aldeles*ikke_func" ].

aldeles-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aldeles_prd ] !>,
    FLAGS.TRIGGER "aldeles_func" ].

aldri*i*verden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aldri*i*verden_prd ] !>,
    FLAGS.TRIGGER "aldri*i*verden_func" ].

aldri*mer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aldri*mer_prd ] !>,
    FLAGS.TRIGGER "aldri*mer_func" ].

aldri-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aldri_prd ] !>,
    FLAGS.TRIGGER "aldri_func" ].

aleine-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aleine_prd ] !>,
    FLAGS.TRIGGER "aleine_func" ].

alene-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alene_prd ] !>,
    FLAGS.TRIGGER "alene_func" ].

alias-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alias_prd ] !>,
    FLAGS.TRIGGER "alias_func" ].

allegretto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allegretto_prd ] !>,
    FLAGS.TRIGGER "allegretto_func" ].

allegro-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allegro_prd ] !>,
    FLAGS.TRIGGER "allegro_func" ].

aller-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED aller_prd ] !>,
    FLAGS.TRIGGER "aller_func" ].

allerede-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allerede_prd ] !>,
    FLAGS.TRIGGER "allerede_func" ].

allesteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allesteds_prd ] !>,
    FLAGS.TRIGGER "allesteds_func" ].

allestedsfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allestedsfra_prd ] !>,
    FLAGS.TRIGGER "allestedsfra_func" ].

allestedshen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allestedshen_prd ] !>,
    FLAGS.TRIGGER "allestedshen_func" ].

allikevel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allikevel_prd ] !>,
    FLAGS.TRIGGER "allikevel_func" ].

allment-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED allment_prd ] !>,
    FLAGS.TRIGGER "allment_func" ].

alltid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alltid_prd ] !>,
    FLAGS.TRIGGER "alltid_func" ].

alltids-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alltids_prd ] !>,
    FLAGS.TRIGGER "alltids_func" ].

alt*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alt*for_prd ] !>,
    FLAGS.TRIGGER "alt*for_func" ].

alt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alt_prd ] !>,
    FLAGS.TRIGGER "alt_func" ].

altfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED altfor_prd ] !>,
    FLAGS.TRIGGER "altfor_func" ].

altså-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED altså_prd ] !>,
    FLAGS.TRIGGER "altså_func" ].

alvorlig*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED alvorlig*talt_prd ] !>,
    FLAGS.TRIGGER "alvorlig*talt_func" ].

amok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED amok_prd ] !>,
    FLAGS.TRIGGER "amok_func" ].

an-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED an_prd ] !>,
    FLAGS.TRIGGER "an_func" ].

ana-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ana_prd ] !>,
    FLAGS.TRIGGER "ana_func" ].

andante-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED andante_prd ] !>,
    FLAGS.TRIGGER "andante_func" ].

andantino-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED andantino_prd ] !>,
    FLAGS.TRIGGER "andantino_func" ].

andelsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED andelsvis_prd ] !>,
    FLAGS.TRIGGER "andelsvis_func" ].

andfares-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED andfares_prd ] !>,
    FLAGS.TRIGGER "andfares_func" ].

andføttes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED andføttes_prd ] !>,
    FLAGS.TRIGGER "andføttes_func" ].

angivelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED angivelig_prd ] !>,
    FLAGS.TRIGGER "angivelig_func" ].

angående-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED angående_prd ] !>,
    FLAGS.TRIGGER "angående_func" ].

annensteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED annensteds_prd ] !>,
    FLAGS.TRIGGER "annensteds_func" ].

annenstedsfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED annenstedsfra_prd ] !>,
    FLAGS.TRIGGER "annenstedsfra_func" ].

annenstedshen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED annenstedshen_prd ] !>,
    FLAGS.TRIGGER "annenstedshen_func" ].

annetsteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED annetsteds_prd ] !>,
    FLAGS.TRIGGER "annetsteds_func" ].

annetstedsfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED annetstedsfra_prd ] !>,
    FLAGS.TRIGGER "annetstedsfra_func" ].

annetstedshen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED annetstedshen_prd ] !>,
    FLAGS.TRIGGER "annetstedshen_func" ].

anno-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED anno_prd ] !>,
    FLAGS.TRIGGER "anno_func" ].

ansikt*til*ansikt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ansikt*til*ansikt_prd ] !>,
    FLAGS.TRIGGER "ansikt*til*ansikt_func" ].

anslagsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED anslagsvis_prd ] !>,
    FLAGS.TRIGGER "anslagsvis_func" ].

anstendigvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED anstendigvis_prd ] !>,
    FLAGS.TRIGGER "anstendigvis_func" ].

anstigende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED anstigende_prd ] !>,
    FLAGS.TRIGGER "anstigende_func" ].

antagelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED antagelig_prd ] !>,
    FLAGS.TRIGGER "antagelig_func" ].

antageligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED antageligvis_prd ] !>,
    FLAGS.TRIGGER "antageligvis_func" ].

antakelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED antakelig_prd ] !>,
    FLAGS.TRIGGER "antakelig_func" ].

antakeligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED antakeligvis_prd ] !>,
    FLAGS.TRIGGER "antakeligvis_func" ].

antatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED antatt_prd ] !>,
    FLAGS.TRIGGER "antatt_func" ].

antydningsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED antydningsvis_prd ] !>,
    FLAGS.TRIGGER "antydningsvis_func" ].

ap-leder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ap-leder_prd ] !>,
    FLAGS.TRIGGER "ap-leder_func" ].

apropos-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED apropos_prd ] !>,
    FLAGS.TRIGGER "apropos_func" ].

argende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED argende_prd ] !>,
    FLAGS.TRIGGER "argende_func" ].

arm*i*arm-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED arm*i*arm_prd ] !>,
    FLAGS.TRIGGER "arm*i*arm_func" ].

atskillig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED atskillig_prd ] !>,
    FLAGS.TRIGGER "atskillig_func" ].

att-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED att_prd ] !>,
    FLAGS.TRIGGER "att_func" ].

attende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED attende_prd ] !>,
    FLAGS.TRIGGER "attende_func" ].

atter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED atter_prd ] !>,
    FLAGS.TRIGGER "atter_func" ].

attpåtil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED attpåtil_prd ] !>,
    FLAGS.TRIGGER "attpåtil_func" ].

attåt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED attåt_prd ] !>,
    FLAGS.TRIGGER "attåt_func" ].

au-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED au_prd ] !>,
    FLAGS.TRIGGER "au_func" ].

austa-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED austa_prd ] !>,
    FLAGS.TRIGGER "austa_func" ].

austafjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED austafjells_prd ] !>,
    FLAGS.TRIGGER "austafjells_func" ].

austfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED austfra_prd ] !>,
    FLAGS.TRIGGER "austfra_func" ].

austover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED austover_prd ] !>,
    FLAGS.TRIGGER "austover_func" ].

austpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED austpå_prd ] !>,
    FLAGS.TRIGGER "austpå_func" ].

av*gårde-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED av*gårde_prd ] !>,
    FLAGS.TRIGGER "av*gårde_func" ].

av*og*til-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED av*og*til_prd ] !>,
    FLAGS.TRIGGER "av*og*til_func" ].

av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED av_prd ] !>,
    FLAGS.TRIGGER "av_func" ].

avdelingsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avdelingsvis_prd ] !>,
    FLAGS.TRIGGER "avdelingsvis_func" ].

avdragsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avdragsvis_prd ] !>,
    FLAGS.TRIGGER "avdragsvis_func" ].

avgjort-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avgjort_prd ] !>,
    FLAGS.TRIGGER "avgjort_func" ].

avgjørende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avgjørende_prd ] !>,
    FLAGS.TRIGGER "avgjørende_func" ].

avgårde-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avgårde_prd ] !>,
    FLAGS.TRIGGER "avgårde_func" ].

avhendes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avhendes_prd ] !>,
    FLAGS.TRIGGER "avhendes_func" ].

avhends-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avhends_prd ] !>,
    FLAGS.TRIGGER "avhends_func" ].

avsatsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avsatsvis_prd ] !>,
    FLAGS.TRIGGER "avsatsvis_func" ].

avslørende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avslørende_prd ] !>,
    FLAGS.TRIGGER "avslørende_func" ].

avsporende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED avsporende_prd ] !>,
    FLAGS.TRIGGER "avsporende_func" ].

babord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED babord_prd ] !>,
    FLAGS.TRIGGER "babord_func" ].

bak-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bak_prd ] !>,
    FLAGS.TRIGGER "bak_func" ].

bakenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakenfor_prd ] !>,
    FLAGS.TRIGGER "bakenfor_func" ].

bakerst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakerst_prd ] !>,
    FLAGS.TRIGGER "bakerst_func" ].

bakfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakfra_prd ] !>,
    FLAGS.TRIGGER "bakfra_func" ].

bakk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakk_prd ] !>,
    FLAGS.TRIGGER "bakk_func" ].

baklengs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED baklengs_prd ] !>,
    FLAGS.TRIGGER "baklengs_func" ].

bakom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakom_prd ] !>,
    FLAGS.TRIGGER "bakom_func" ].

bakover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakover_prd ] !>,
    FLAGS.TRIGGER "bakover_func" ].

bakut-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bakut_prd ] !>,
    FLAGS.TRIGGER "bakut_func" ].

bare-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bare_prd ] !>,
    FLAGS.TRIGGER "bare_func" ].

bataljonsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bataljonsvis_prd ] !>,
    FLAGS.TRIGGER "bataljonsvis_func" ].

bedre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bedre_prd ] !>,
    FLAGS.TRIGGER "bedre_func" ].

befriende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED befriende_prd ] !>,
    FLAGS.TRIGGER "befriende_func" ].

bekende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bekende_prd ] !>,
    FLAGS.TRIGGER "bekende_func" ].

belgende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED belgende_prd ] !>,
    FLAGS.TRIGGER "belgende_func" ].

beskjedne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED beskjedne_prd ] !>,
    FLAGS.TRIGGER "beskjedne_func" ].

besnærende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED besnærende_prd ] !>,
    FLAGS.TRIGGER "besnærende_func" ].

best-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED best_prd ] !>,
    FLAGS.TRIGGER "best_func" ].

bestandig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bestandig_prd ] !>,
    FLAGS.TRIGGER "bestandig_func" ].

bestefar-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bestefar_prd ] !>,
    FLAGS.TRIGGER "bestefar_func" ].

betalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED betalt_prd ] !>,
    FLAGS.TRIGGER "betalt_func" ].

betids-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED betids_prd ] !>,
    FLAGS.TRIGGER "betids_func" ].

betraktelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED betraktelig_prd ] !>,
    FLAGS.TRIGGER "betraktelig_func" ].

betydelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED betydelig_prd ] !>,
    FLAGS.TRIGGER "betydelig_func" ].

bi-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bi_prd ] !>,
    FLAGS.TRIGGER "bi_func" ].

bidevind-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bidevind_prd ] !>,
    FLAGS.TRIGGER "bidevind_func" ].

billedlig*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED billedlig*talt_prd ] !>,
    FLAGS.TRIGGER "billedlig*talt_func" ].

bis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bis_prd ] !>,
    FLAGS.TRIGGER "bis_func" ].

bitende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bitende_prd ] !>,
    FLAGS.TRIGGER "bitende_func" ].

bitevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bitevis_prd ] !>,
    FLAGS.TRIGGER "bitevis_func" ].

bitte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bitte_prd ] !>,
    FLAGS.TRIGGER "bitte_func" ].

bitterlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bitterlig_prd ] !>,
    FLAGS.TRIGGER "bitterlig_func" ].

bl*a-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bl*a_prd ] !>,
    FLAGS.TRIGGER "bl*a_func" ].

blankende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blankende_prd ] !>,
    FLAGS.TRIGGER "blankende_func" ].

blanko-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blanko_prd ] !>,
    FLAGS.TRIGGER "blanko_func" ].

blant*annet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blant*annet_prd ] !>,
    FLAGS.TRIGGER "blant*annet_func" ].

blant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blant_prd ] !>,
    FLAGS.TRIGGER "blant_func" ].

blekt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blekt_prd ] !>,
    FLAGS.TRIGGER "blekt_func" ].

blendende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blendende_prd ] !>,
    FLAGS.TRIGGER "blendende_func" ].

blidelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blidelig_prd ] !>,
    FLAGS.TRIGGER "blidelig_func" ].

blikk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blikk_prd ] !>,
    FLAGS.TRIGGER "blikk_func" ].

blikkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blikkende_prd ] !>,
    FLAGS.TRIGGER "blikkende_func" ].

blottende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blottende_prd ] !>,
    FLAGS.TRIGGER "blottende_func" ].

blperiodaperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blperiodaperiod_prd ] !>,
    FLAGS.TRIGGER "blperiodaperiod_func" ].

blussende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED blussende_prd ] !>,
    FLAGS.TRIGGER "blussende_func" ].

bokstavelig*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bokstavelig*talt_prd ] !>,
    FLAGS.TRIGGER "bokstavelig*talt_func" ].

bokstavlig*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bokstavlig*talt_prd ] !>,
    FLAGS.TRIGGER "bokstavlig*talt_func" ].

bom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bom_prd ] !>,
    FLAGS.TRIGGER "bom_func" ].

bommende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bommende_prd ] !>,
    FLAGS.TRIGGER "bommende_func" ].

bort*i*mot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bort*i*mot_prd ] !>,
    FLAGS.TRIGGER "bort*i*mot_func" ].

bort-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bort_prd ] !>,
    FLAGS.TRIGGER "bort_func" ].

borte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED borte_prd ] !>,
    FLAGS.TRIGGER "borte_func" ].

bortefra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bortefra_prd ] !>,
    FLAGS.TRIGGER "bortefra_func" ].

bortenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bortenfor_prd ] !>,
    FLAGS.TRIGGER "bortenfor_func" ].

borti-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED borti_prd ] !>,
    FLAGS.TRIGGER "borti_func" ].

bortimot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bortimot_prd ] !>,
    FLAGS.TRIGGER "bortimot_func" ].

bortom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bortom_prd ] !>,
    FLAGS.TRIGGER "bortom_func" ].

bortover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bortover_prd ] !>,
    FLAGS.TRIGGER "bortover_func" ].

bortsett*fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bortsett*fra_prd ] !>,
    FLAGS.TRIGGER "bortsett*fra_func" ].

borttil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED borttil_prd ] !>,
    FLAGS.TRIGGER "borttil_func" ].

brakk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED brakk_prd ] !>,
    FLAGS.TRIGGER "brakk_func" ].

bredt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bredt_prd ] !>,
    FLAGS.TRIGGER "bredt_func" ].

brennende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED brennende_prd ] !>,
    FLAGS.TRIGGER "brennende_func" ].

brennfort-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED brennfort_prd ] !>,
    FLAGS.TRIGGER "brennfort_func" ].

brother-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED brother_prd ] !>,
    FLAGS.TRIGGER "brother_func" ].

brutalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED brutalt_prd ] !>,
    FLAGS.TRIGGER "brutalt_func" ].

brutto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED brutto_prd ] !>,
    FLAGS.TRIGGER "brutto_func" ].

bråtevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bråtevis_prd ] !>,
    FLAGS.TRIGGER "bråtevis_func" ].

bums-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bums_prd ] !>,
    FLAGS.TRIGGER "bums_func" ].

buntevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED buntevis_prd ] !>,
    FLAGS.TRIGGER "buntevis_func" ].

buntvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED buntvis_prd ] !>,
    FLAGS.TRIGGER "buntvis_func" ].

bus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bus_prd ] !>,
    FLAGS.TRIGGER "bus_func" ].

bygdimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED bygdimellom_prd ] !>,
    FLAGS.TRIGGER "bygdimellom_func" ].

både*lenge*og*vel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED både*lenge*og*vel_prd ] !>,
    FLAGS.TRIGGER "både*lenge*og*vel_func" ].

ca-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ca_prd ] !>,
    FLAGS.TRIGGER "ca_func" ].

cantabile-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED cantabile_prd ] !>,
    FLAGS.TRIGGER "cantabile_func" ].

caperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED caperiod_prd ] !>,
    FLAGS.TRIGGER "caperiod_func" ].

cf-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED cf_prd ] !>,
    FLAGS.TRIGGER "cf_func" ].

cif-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED cif_prd ] !>,
    FLAGS.TRIGGER "cif_func" ].

cirka-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED cirka_prd ] !>,
    FLAGS.TRIGGER "cirka_func" ].

coolly-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED coolly_prd ] !>,
    FLAGS.TRIGGER "coolly_func" ].

crescendo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED crescendo_prd ] !>,
    FLAGS.TRIGGER "crescendo_func" ].

cslasho-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED cslasho_prd ] !>,
    FLAGS.TRIGGER "cslasho_func" ].

da-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED da_prd ] !>,
    FLAGS.TRIGGER "da_func" ].

dag*for*dag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dag*for*dag_prd ] !>,
    FLAGS.TRIGGER "dag*for*dag_func" ].

dag*og*natt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dag*og*natt_prd ] !>,
    FLAGS.TRIGGER "dag*og*natt_func" ].

dag-for-dag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dag-for-dag_prd ] !>,
    FLAGS.TRIGGER "dag-for-dag_func" ].

dagevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dagevis_prd ] !>,
    FLAGS.TRIGGER "dagevis_func" ].

daglig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED daglig_prd ] !>,
    FLAGS.TRIGGER "daglig_func" ].

dagstøtt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dagstøtt_prd ] !>,
    FLAGS.TRIGGER "dagstøtt_func" ].

dakapo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dakapo_prd ] !>,
    FLAGS.TRIGGER "dakapo_func" ].

dam-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dam_prd ] !>,
    FLAGS.TRIGGER "dam_func" ].

dammende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dammende_prd ] !>,
    FLAGS.TRIGGER "dammende_func" ].

dann-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dann_prd ] !>,
    FLAGS.TRIGGER "dann_func" ].

decrescendo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED decrescendo_prd ] !>,
    FLAGS.TRIGGER "decrescendo_func" ].

delkredere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED delkredere_prd ] !>,
    FLAGS.TRIGGER "delkredere_func" ].

dels-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dels_prd ] !>,
    FLAGS.TRIGGER "dels_func" ].

delvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED delvis_prd ] !>,
    FLAGS.TRIGGER "delvis_func" ].

den*dag*i*dag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED den*dag*i*dag_prd ] !>,
    FLAGS.TRIGGER "den*dag*i*dag_func" ].

den*gang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED den*gang_prd ] !>,
    FLAGS.TRIGGER "den*gang_func" ].

dengang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dengang_prd ] !>,
    FLAGS.TRIGGER "dengang_func" ].

der*hen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der*hen_prd ] !>,
    FLAGS.TRIGGER "der*hen_func" ].

der*inne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der*inne_prd ] !>,
    FLAGS.TRIGGER "der*inne_func" ].

der*nede-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der*nede_prd ] !>,
    FLAGS.TRIGGER "der*nede_func" ].

der*og*da-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der*og*da_prd ] !>,
    FLAGS.TRIGGER "der*og*da_func" ].

der*oppe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der*oppe_prd ] !>,
    FLAGS.TRIGGER "der*oppe_func" ].

der*ute-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der*ute_prd ] !>,
    FLAGS.TRIGGER "der*ute_func" ].

der-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED der_prd ] !>,
    FLAGS.TRIGGER "der_func" ].

derav-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derav_prd ] !>,
    FLAGS.TRIGGER "derav_func" ].

deretter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED deretter_prd ] !>,
    FLAGS.TRIGGER "deretter_func" ].

derfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derfor_prd ] !>,
    FLAGS.TRIGGER "derfor_func" ].

derfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derfra_prd ] !>,
    FLAGS.TRIGGER "derfra_func" ].

deri-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED deri_prd ] !>,
    FLAGS.TRIGGER "deri_func" ].

deriblant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED deriblant_prd ] !>,
    FLAGS.TRIGGER "deriblant_func" ].

derifra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derifra_prd ] !>,
    FLAGS.TRIGGER "derifra_func" ].

derimot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derimot_prd ] !>,
    FLAGS.TRIGGER "derimot_func" ].

dermed-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dermed_prd ] !>,
    FLAGS.TRIGGER "dermed_func" ].

dernest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dernest_prd ] !>,
    FLAGS.TRIGGER "dernest_func" ].

derom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derom_prd ] !>,
    FLAGS.TRIGGER "derom_func" ].

derpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derpå_prd ] !>,
    FLAGS.TRIGGER "derpå_func" ].

dersom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dersom_prd ] !>,
    FLAGS.TRIGGER "dersom_func" ].

dersomatte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dersomatte_prd ] !>,
    FLAGS.TRIGGER "dersomatte_func" ].

dertil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dertil_prd ] !>,
    FLAGS.TRIGGER "dertil_func" ].

derved-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED derved_prd ] !>,
    FLAGS.TRIGGER "derved_func" ].

dess-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dess_prd ] !>,
    FLAGS.TRIGGER "dess_func" ].

dessuten-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dessuten_prd ] !>,
    FLAGS.TRIGGER "dessuten_func" ].

dessverre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dessverre_prd ] !>,
    FLAGS.TRIGGER "dessverre_func" ].

desto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED desto_prd ] !>,
    FLAGS.TRIGGER "desto_func" ].

det*minste-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED det*minste_prd ] !>,
    FLAGS.TRIGGER "det*minste_func" ].

det*spor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED det*spor_prd ] !>,
    FLAGS.TRIGGER "det*spor_func" ].

diktet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED diktet_prd ] !>,
    FLAGS.TRIGGER "diktet_func" ].

diminuendo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED diminuendo_prd ] !>,
    FLAGS.TRIGGER "diminuendo_func" ].

direkte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED direkte_prd ] !>,
    FLAGS.TRIGGER "direkte_func" ].

dis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dis_prd ] !>,
    FLAGS.TRIGGER "dis_func" ].

dit-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dit_prd ] !>,
    FLAGS.TRIGGER "dit_func" ].

ditover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ditover_prd ] !>,
    FLAGS.TRIGGER "ditover_func" ].

djupt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED djupt_prd ] !>,
    FLAGS.TRIGGER "djupt_func" ].

dobbelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dobbelt_prd ] !>,
    FLAGS.TRIGGER "dobbelt_func" ].

dog-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dog_prd ] !>,
    FLAGS.TRIGGER "dog_func" ].

dolce-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dolce_prd ] !>,
    FLAGS.TRIGGER "dolce_func" ].

dona-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dona_prd ] !>,
    FLAGS.TRIGGER "dona_func" ].

dorgende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dorgende_prd ] !>,
    FLAGS.TRIGGER "dorgende_func" ].

drepende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drepende_prd ] !>,
    FLAGS.TRIGGER "drepende_func" ].

drit-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drit_prd ] !>,
    FLAGS.TRIGGER "drit_func" ].

drita-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drita_prd ] !>,
    FLAGS.TRIGGER "drita_func" ].

drivende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drivende_prd ] !>,
    FLAGS.TRIGGER "drivende_func" ].

drperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drperiod_prd ] !>,
    FLAGS.TRIGGER "drperiod_func" ].

dryppende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dryppende_prd ] !>,
    FLAGS.TRIGGER "dryppende_func" ].

dryssende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dryssende_prd ] !>,
    FLAGS.TRIGGER "dryssende_func" ].

drøssevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drøssevis_prd ] !>,
    FLAGS.TRIGGER "drøssevis_func" ].

drøye-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drøye_prd ] !>,
    FLAGS.TRIGGER "drøye_func" ].

drøyt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED drøyt_prd ] !>,
    FLAGS.TRIGGER "drøyt_func" ].

dundrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dundrende_prd ] !>,
    FLAGS.TRIGGER "dundrende_func" ].

dus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dus_prd ] !>,
    FLAGS.TRIGGER "dus_func" ].

dusinvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dusinvis_prd ] !>,
    FLAGS.TRIGGER "dusinvis_func" ].

dyende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dyende_prd ] !>,
    FLAGS.TRIGGER "dyende_func" ].

dypt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dypt_prd ] !>,
    FLAGS.TRIGGER "dypt_func" ].

dystert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dystert_prd ] !>,
    FLAGS.TRIGGER "dystert_func" ].

dødelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dødelig_prd ] !>,
    FLAGS.TRIGGER "dødelig_func" ].

dødsens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dødsens_prd ] !>,
    FLAGS.TRIGGER "dødsens_func" ].

døgnvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED døgnvis_prd ] !>,
    FLAGS.TRIGGER "døgnvis_func" ].

dønn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dønn_prd ] !>,
    FLAGS.TRIGGER "dønn_func" ].

dørg-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dørg_prd ] !>,
    FLAGS.TRIGGER "dørg_func" ].

dørgende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dørgende_prd ] !>,
    FLAGS.TRIGGER "dørgende_func" ].

dørimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED dørimellom_prd ] !>,
    FLAGS.TRIGGER "dørimellom_func" ].

efter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED efter_prd ] !>,
    FLAGS.TRIGGER "efter_func" ].

efterhånden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED efterhånden_prd ] !>,
    FLAGS.TRIGGER "efterhånden_func" ].

efterpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED efterpå_prd ] !>,
    FLAGS.TRIGGER "efterpå_func" ].

egentlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED egentlig_prd ] !>,
    FLAGS.TRIGGER "egentlig_func" ].

ei*for*ei-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ei*for*ei_prd ] !>,
    FLAGS.TRIGGER "ei*for*ei_func" ].

ei-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ei_prd ] !>,
    FLAGS.TRIGGER "ei_func" ].

eiende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eiende_prd ] !>,
    FLAGS.TRIGGER "eiende_func" ].

einkom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED einkom_prd ] !>,
    FLAGS.TRIGGER "einkom_func" ].

eitrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eitrende_prd ] !>,
    FLAGS.TRIGGER "eitrende_func" ].

eks-dronning-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eks-dronning_prd ] !>,
    FLAGS.TRIGGER "eks-dronning_func" ].

eksempelvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eksempelvis_prd ] !>,
    FLAGS.TRIGGER "eksempelvis_func" ].

eksklusiv-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eksklusiv_prd ] !>,
    FLAGS.TRIGGER "eksklusiv_func" ].

eksklusive-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eksklusive_prd ] !>,
    FLAGS.TRIGGER "eksklusive_func" ].

ekspress-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ekspress_prd ] !>,
    FLAGS.TRIGGER "ekspress_func" ].

ekstempore-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ekstempore_prd ] !>,
    FLAGS.TRIGGER "ekstempore_func" ].

ekstra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ekstra_prd ] !>,
    FLAGS.TRIGGER "ekstra_func" ].

ekstraordinært-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ekstraordinært_prd ] !>,
    FLAGS.TRIGGER "ekstraordinært_func" ].

ekstremt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ekstremt_prd ] !>,
    FLAGS.TRIGGER "ekstremt_func" ].

eldende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eldende_prd ] !>,
    FLAGS.TRIGGER "eldende_func" ].

ellers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ellers_prd ] !>,
    FLAGS.TRIGGER "ellers_func" ].

emosjonelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED emosjonelt_prd ] !>,
    FLAGS.TRIGGER "emosjonelt_func" ].

en*anelse-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*anelse_prd ] !>,
    FLAGS.TRIGGER "en*anelse_func" ].

en*del-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*del_prd ] !>,
    FLAGS.TRIGGER "en*del_func" ].

en*etter*en-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*etter*en_prd ] !>,
    FLAGS.TRIGGER "en*etter*en_func" ].

en*for*en-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*for*en_prd ] !>,
    FLAGS.TRIGGER "en*for*en_func" ].

en*gang*i*blant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*gang*i*blant_prd ] !>,
    FLAGS.TRIGGER "en*gang*i*blant_func" ].

en*gang*iblant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*gang*iblant_prd ] !>,
    FLAGS.TRIGGER "en*gang*iblant_func" ].

en*god*del-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*god*del_prd ] !>,
    FLAGS.TRIGGER "en*god*del_func" ].

en*hel*del-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*hel*del_prd ] !>,
    FLAGS.TRIGGER "en*hel*del_func" ].

en*smule-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED en*smule_prd ] !>,
    FLAGS.TRIGGER "en*smule_func" ].

enda-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enda_prd ] !>,
    FLAGS.TRIGGER "enda_func" ].

endatil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED endatil_prd ] !>,
    FLAGS.TRIGGER "endatil_func" ].

ende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ende_prd ] !>,
    FLAGS.TRIGGER "ende_func" ].

endel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED endel_prd ] !>,
    FLAGS.TRIGGER "endel_func" ].

endelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED endelig_prd ] !>,
    FLAGS.TRIGGER "endelig_func" ].

ender-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ender_prd ] !>,
    FLAGS.TRIGGER "ender_func" ].

endog-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED endog_prd ] !>,
    FLAGS.TRIGGER "endog_func" ].

ene-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ene_prd ] !>,
    FLAGS.TRIGGER "ene_func" ].

enestående-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enestående_prd ] !>,
    FLAGS.TRIGGER "enestående_func" ].

engang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED engang_prd ] !>,
    FLAGS.TRIGGER "engang_func" ].

enkeltvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enkeltvis_prd ] !>,
    FLAGS.TRIGGER "enkeltvis_func" ].

enkom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enkom_prd ] !>,
    FLAGS.TRIGGER "enkom_func" ].

enn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enn_prd ] !>,
    FLAGS.TRIGGER "enn_func" ].

ennu-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ennu_prd ] !>,
    FLAGS.TRIGGER "ennu_func" ].

ennå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ennå_prd ] !>,
    FLAGS.TRIGGER "ennå_func" ].

enormt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enormt_prd ] !>,
    FLAGS.TRIGGER "enormt_func" ].

ensfarvet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ensfarvet_prd ] !>,
    FLAGS.TRIGGER "ensfarvet_func" ].

ensteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ensteds_prd ] !>,
    FLAGS.TRIGGER "ensteds_func" ].

enten-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED enten_prd ] !>,
    FLAGS.TRIGGER "enten_func" ].

ergo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ergo_prd ] !>,
    FLAGS.TRIGGER "ergo_func" ].

et*godt*stykke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED et*godt*stykke_prd ] !>,
    FLAGS.TRIGGER "et*godt*stykke_func" ].

etappevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etappevis_prd ] !>,
    FLAGS.TRIGGER "etappevis_func" ].

ett*for*ett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ett*for*ett_prd ] !>,
    FLAGS.TRIGGER "ett*for*ett_func" ].

etter*alt*å*dømme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etter*alt*å*dømme_prd ] !>,
    FLAGS.TRIGGER "etter*alt*å*dømme_func" ].

etter*hvert*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etter*hvert*som_prd ] !>,
    FLAGS.TRIGGER "etter*hvert*som_func" ].

etter*hvert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etter*hvert_prd ] !>,
    FLAGS.TRIGGER "etter*hvert_func" ].

etter*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etter*som_prd ] !>,
    FLAGS.TRIGGER "etter*som_func" ].

etter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etter_prd ] !>,
    FLAGS.TRIGGER "etter_func" ].

etterat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterat_prd ] !>,
    FLAGS.TRIGGER "etterat_func" ].

etterhvert*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterhvert*som_prd ] !>,
    FLAGS.TRIGGER "etterhvert*som_func" ].

etterhvert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterhvert_prd ] !>,
    FLAGS.TRIGGER "etterhvert_func" ].

etterhånden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterhånden_prd ] !>,
    FLAGS.TRIGGER "etterhånden_func" ].

etterpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterpå_prd ] !>,
    FLAGS.TRIGGER "etterpå_func" ].

etterskottsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterskottsvis_prd ] !>,
    FLAGS.TRIGGER "etterskottsvis_func" ].

etterskuddsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED etterskuddsvis_prd ] !>,
    FLAGS.TRIGGER "etterskuddsvis_func" ].

ettersom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ettersom_prd ] !>,
    FLAGS.TRIGGER "ettersom_func" ].

eventuelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED eventuelt_prd ] !>,
    FLAGS.TRIGGER "eventuelt_func" ].

evperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED evperiod_prd ] !>,
    FLAGS.TRIGGER "evperiod_func" ].

evtperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED evtperiod_prd ] !>,
    FLAGS.TRIGGER "evtperiod_func" ].

f*periodeks*period-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED f*periodeks*period_prd ] !>,
    FLAGS.TRIGGER "f*periodeks*period_func" ].

fader-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fader_prd ] !>,
    FLAGS.TRIGGER "fader_func" ].

faderlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED faderlig_prd ] !>,
    FLAGS.TRIGGER "faderlig_func" ].

faen*meg-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED faen*meg_prd ] !>,
    FLAGS.TRIGGER "faen*meg_func" ].

faen*så-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED faen*så_prd ] !>,
    FLAGS.TRIGGER "faen*så_func" ].

faktisk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED faktisk_prd ] !>,
    FLAGS.TRIGGER "faktisk_func" ].

familien-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED familien_prd ] !>,
    FLAGS.TRIGGER "familien_func" ].

fantastisk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fantastisk_prd ] !>,
    FLAGS.TRIGGER "fantastisk_func" ].

far-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED far_prd ] !>,
    FLAGS.TRIGGER "far_func" ].

faretruende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED faretruende_prd ] !>,
    FLAGS.TRIGGER "faretruende_func" ].

fas-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fas_prd ] !>,
    FLAGS.TRIGGER "fas_func" ].

fast-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fast_prd ] !>,
    FLAGS.TRIGGER "fast_func" ].

fatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fatt_prd ] !>,
    FLAGS.TRIGGER "fatt_func" ].

feiende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED feiende_prd ] !>,
    FLAGS.TRIGGER "feiende_func" ].

feil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED feil_prd ] !>,
    FLAGS.TRIGGER "feil_func" ].

femti-femti-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED femti-femti_prd ] !>,
    FLAGS.TRIGGER "femti-femti_func" ].

fifty-fifty-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fifty-fifty_prd ] !>,
    FLAGS.TRIGGER "fifty-fifty_func" ].

figur-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED figur_prd ] !>,
    FLAGS.TRIGGER "figur_func" ].

fjellguide-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fjellguide_prd ] !>,
    FLAGS.TRIGGER "fjellguide_func" ].

fjærende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fjærende_prd ] !>,
    FLAGS.TRIGGER "fjærende_func" ].

flammende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED flammende_prd ] !>,
    FLAGS.TRIGGER "flammende_func" ].

flekkevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED flekkevis_prd ] !>,
    FLAGS.TRIGGER "flekkevis_func" ].

flokkevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED flokkevis_prd ] !>,
    FLAGS.TRIGGER "flokkevis_func" ].

fluks-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fluks_prd ] !>,
    FLAGS.TRIGGER "fluks_func" ].

fluksens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fluksens_prd ] !>,
    FLAGS.TRIGGER "fluksens_func" ].

flunkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED flunkende_prd ] !>,
    FLAGS.TRIGGER "flunkende_func" ].

flust-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED flust_prd ] !>,
    FLAGS.TRIGGER "flust_func" ].

fly-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fly_prd ] !>,
    FLAGS.TRIGGER "fly_func" ].

flyende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED flyende_prd ] !>,
    FLAGS.TRIGGER "flyende_func" ].

fob-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fob_prd ] !>,
    FLAGS.TRIGGER "fob_func" ].

for*all*del-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*all*del_prd ] !>,
    FLAGS.TRIGGER "for*all*del_func" ].

for*alltid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*alltid_prd ] !>,
    FLAGS.TRIGGER "for*alltid_func" ].

for*alvor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*alvor_prd ] !>,
    FLAGS.TRIGGER "for*alvor_func" ].

for*at-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*at_prd ] !>,
    FLAGS.TRIGGER "for*at_func" ].

for*eksempel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*eksempel_prd ] !>,
    FLAGS.TRIGGER "for*eksempel_func" ].

for*gitt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*gitt_prd ] !>,
    FLAGS.TRIGGER "for*gitt_func" ].

for*ikke*lenge*siden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*ikke*lenge*siden_prd ] !>,
    FLAGS.TRIGGER "for*ikke*lenge*siden_func" ].

for*lenge*siden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*lenge*siden_prd ] !>,
    FLAGS.TRIGGER "for*lenge*siden_func" ].

for*moro*skyld-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*moro*skyld_prd ] !>,
    FLAGS.TRIGGER "for*moro*skyld_func" ].

for*så*vidt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*så*vidt_prd ] !>,
    FLAGS.TRIGGER "for*så*vidt_func" ].

for*tida-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*tida_prd ] !>,
    FLAGS.TRIGGER "for*tida_func" ].

for*tiden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*tiden_prd ] !>,
    FLAGS.TRIGGER "for*tiden_func" ].

for*øvrig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*øvrig_prd ] !>,
    FLAGS.TRIGGER "for*øvrig_func" ].

for*øyeblikket-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for*øyeblikket_prd ] !>,
    FLAGS.TRIGGER "for*øyeblikket_func" ].

for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED for_prd ] !>,
    FLAGS.TRIGGER "for_func" ].

foran-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED foran_prd ] !>,
    FLAGS.TRIGGER "foran_func" ].

forat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forat_prd ] !>,
    FLAGS.TRIGGER "forat_func" ].

forbanna-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forbanna_prd ] !>,
    FLAGS.TRIGGER "forbanna_func" ].

forbannet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forbannet_prd ] !>,
    FLAGS.TRIGGER "forbannet_func" ].

forbasket-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forbasket_prd ] !>,
    FLAGS.TRIGGER "forbasket_func" ].

forbausende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forbausende_prd ] !>,
    FLAGS.TRIGGER "forbausende_func" ].

forbi-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forbi_prd ] !>,
    FLAGS.TRIGGER "forbi_func" ].

forbløffende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forbløffende_prd ] !>,
    FLAGS.TRIGGER "forbløffende_func" ].

fordevind-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fordevind_prd ] !>,
    FLAGS.TRIGGER "fordevind_func" ].

fordi*at-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fordi*at_prd ] !>,
    FLAGS.TRIGGER "fordi*at_func" ].

fordi*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fordi*om_prd ] !>,
    FLAGS.TRIGGER "fordi*om_func" ].

fordi-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fordi_prd ] !>,
    FLAGS.TRIGGER "fordi_func" ].

fordum-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fordum_prd ] !>,
    FLAGS.TRIGGER "fordum_func" ].

fordømt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fordømt_prd ] !>,
    FLAGS.TRIGGER "fordømt_func" ].

fore-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fore_prd ] !>,
    FLAGS.TRIGGER "fore_func" ].

foreløpig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED foreløpig_prd ] !>,
    FLAGS.TRIGGER "foreløpig_func" ].

forferdelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forferdelig_prd ] !>,
    FLAGS.TRIGGER "forferdelig_func" ].

forfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forfra_prd ] !>,
    FLAGS.TRIGGER "forfra_func" ].

forhakkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forhakkende_prd ] !>,
    FLAGS.TRIGGER "forhakkende_func" ].

forholdsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forholdsvis_prd ] !>,
    FLAGS.TRIGGER "forholdsvis_func" ].

forhåpentlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forhåpentlig_prd ] !>,
    FLAGS.TRIGGER "forhåpentlig_func" ].

forhåpentligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forhåpentligvis_prd ] !>,
    FLAGS.TRIGGER "forhåpentligvis_func" ].

forlengs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forlengs_prd ] !>,
    FLAGS.TRIGGER "forlengs_func" ].

forlengst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forlengst_prd ] !>,
    FLAGS.TRIGGER "forlengst_func" ].

forlokkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forlokkende_prd ] !>,
    FLAGS.TRIGGER "forlokkende_func" ].

formelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED formelig_prd ] !>,
    FLAGS.TRIGGER "formelig_func" ].

formelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED formelt_prd ] !>,
    FLAGS.TRIGGER "formelt_func" ].

formerlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED formerlig_prd ] !>,
    FLAGS.TRIGGER "formerlig_func" ].

formodentlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED formodentlig_prd ] !>,
    FLAGS.TRIGGER "formodentlig_func" ].

forover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forover_prd ] !>,
    FLAGS.TRIGGER "forover_func" ].

forresten-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forresten_prd ] !>,
    FLAGS.TRIGGER "forresten_func" ].

forskrekkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forskrekkelig_prd ] !>,
    FLAGS.TRIGGER "forskrekkelig_func" ].

forstemmende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forstemmende_prd ] !>,
    FLAGS.TRIGGER "forstemmende_func" ].

forsvinnende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forsvinnende_prd ] !>,
    FLAGS.TRIGGER "forsvinnende_func" ].

forsåvidt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forsåvidt_prd ] !>,
    FLAGS.TRIGGER "forsåvidt_func" ].

forsøksvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forsøksvis_prd ] !>,
    FLAGS.TRIGGER "forsøksvis_func" ].

fort-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fort_prd ] !>,
    FLAGS.TRIGGER "fort_func" ].

forte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forte_prd ] !>,
    FLAGS.TRIGGER "forte_func" ].

fortfarende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fortfarende_prd ] !>,
    FLAGS.TRIGGER "fortfarende_func" ].

fortissimo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fortissimo_prd ] !>,
    FLAGS.TRIGGER "fortissimo_func" ].

fortrinnsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fortrinnsvis_prd ] !>,
    FLAGS.TRIGGER "fortrinnsvis_func" ].

fortsatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fortsatt_prd ] !>,
    FLAGS.TRIGGER "fortsatt_func" ].

foruroligende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED foruroligende_prd ] !>,
    FLAGS.TRIGGER "foruroligende_func" ].

forut-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forut_prd ] !>,
    FLAGS.TRIGGER "forut_func" ].

foruten-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED foruten_prd ] !>,
    FLAGS.TRIGGER "foruten_func" ].

forutsatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forutsatt_prd ] !>,
    FLAGS.TRIGGER "forutsatt_func" ].

forøvrig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED forøvrig_prd ] !>,
    FLAGS.TRIGGER "forøvrig_func" ].

fra*da*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra*da*av_prd ] !>,
    FLAGS.TRIGGER "fra*da*av_func" ].

fra*eller*til-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra*eller*til_prd ] !>,
    FLAGS.TRIGGER "fra*eller*til_func" ].

fra*før*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra*før*av_prd ] !>,
    FLAGS.TRIGGER "fra*før*av_func" ].

fra*før-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra*før_prd ] !>,
    FLAGS.TRIGGER "fra*før_func" ].

fra*nå*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra*nå*av_prd ] !>,
    FLAGS.TRIGGER "fra*nå*av_func" ].

fra*tid*til*annen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra*tid*til*annen_prd ] !>,
    FLAGS.TRIGGER "fra*tid*til*annen_func" ].

fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fra_prd ] !>,
    FLAGS.TRIGGER "fra_func" ].

frabedt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frabedt_prd ] !>,
    FLAGS.TRIGGER "frabedt_func" ].

fram*og*tilbake-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fram*og*tilbake_prd ] !>,
    FLAGS.TRIGGER "fram*og*tilbake_func" ].

fram-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fram_prd ] !>,
    FLAGS.TRIGGER "fram_func" ].

framfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framfor_prd ] !>,
    FLAGS.TRIGGER "framfor_func" ].

framføre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framføre_prd ] !>,
    FLAGS.TRIGGER "framføre_func" ].

framleis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framleis_prd ] !>,
    FLAGS.TRIGGER "framleis_func" ].

framlengs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framlengs_prd ] !>,
    FLAGS.TRIGGER "framlengs_func" ].

framme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framme_prd ] !>,
    FLAGS.TRIGGER "framme_func" ].

framover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framover_prd ] !>,
    FLAGS.TRIGGER "framover_func" ].

frampå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frampå_prd ] !>,
    FLAGS.TRIGGER "frampå_func" ].

framstupes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framstupes_prd ] !>,
    FLAGS.TRIGGER "framstupes_func" ].

framstups-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED framstups_prd ] !>,
    FLAGS.TRIGGER "framstups_func" ].

franko-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED franko_prd ] !>,
    FLAGS.TRIGGER "franko_func" ].

frem*og*tilbake-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frem*og*tilbake_prd ] !>,
    FLAGS.TRIGGER "frem*og*tilbake_func" ].

frem-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frem_prd ] !>,
    FLAGS.TRIGGER "frem_func" ].

fremad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremad_prd ] !>,
    FLAGS.TRIGGER "fremad_func" ].

fremdeles-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremdeles_prd ] !>,
    FLAGS.TRIGGER "fremdeles_func" ].

fremfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremfor_prd ] !>,
    FLAGS.TRIGGER "fremfor_func" ].

fremlengs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremlengs_prd ] !>,
    FLAGS.TRIGGER "fremlengs_func" ].

fremme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremme_prd ] !>,
    FLAGS.TRIGGER "fremme_func" ].

fremover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremover_prd ] !>,
    FLAGS.TRIGGER "fremover_func" ].

frempå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frempå_prd ] !>,
    FLAGS.TRIGGER "frempå_func" ].

fremstupes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremstupes_prd ] !>,
    FLAGS.TRIGGER "fremstupes_func" ].

fremstups-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fremstups_prd ] !>,
    FLAGS.TRIGGER "fremstups_func" ].

fri-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fri_prd ] !>,
    FLAGS.TRIGGER "fri_func" ].

frperiodpperiod-formann-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frperiodpperiod-formann_prd ] !>,
    FLAGS.TRIGGER "frperiodpperiod-formann_func" ].

fru-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fru_prd ] !>,
    FLAGS.TRIGGER "fru_func" ].

fryktelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fryktelig_prd ] !>,
    FLAGS.TRIGGER "fryktelig_func" ].

frøken-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED frøken_prd ] !>,
    FLAGS.TRIGGER "frøken_func" ].

fullkomment-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fullkomment_prd ] !>,
    FLAGS.TRIGGER "fullkomment_func" ].

fullstendig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fullstendig_prd ] !>,
    FLAGS.TRIGGER "fullstendig_func" ].

fullt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fullt_prd ] !>,
    FLAGS.TRIGGER "fullt_func" ].

fundamentalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fundamentalt_prd ] !>,
    FLAGS.TRIGGER "fundamentalt_func" ].

furioso-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED furioso_prd ] !>,
    FLAGS.TRIGGER "furioso_func" ].

fykende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fykende_prd ] !>,
    FLAGS.TRIGGER "fykende_func" ].

fylkesvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fylkesvis_prd ] !>,
    FLAGS.TRIGGER "fylkesvis_func" ].

fælt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED fælt_prd ] !>,
    FLAGS.TRIGGER "fælt_func" ].

følelsesmessig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED følelsesmessig_prd ] !>,
    FLAGS.TRIGGER "følelsesmessig_func" ].

følgelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED følgelig_prd ] !>,
    FLAGS.TRIGGER "følgelig_func" ].

før-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED før_prd ] !>,
    FLAGS.TRIGGER "før_func" ].

føre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED føre_prd ] !>,
    FLAGS.TRIGGER "føre_func" ].

førenn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED førenn_prd ] !>,
    FLAGS.TRIGGER "førenn_func" ].

først*og*fremst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED først*og*fremst_prd ] !>,
    FLAGS.TRIGGER "først*og*fremst_func" ].

først*som*sist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED først*som*sist_prd ] !>,
    FLAGS.TRIGGER "først*som*sist_func" ].

først-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED først_prd ] !>,
    FLAGS.TRIGGER "først_func" ].

gang*på*gang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gang*på*gang_prd ] !>,
    FLAGS.TRIGGER "gang*på*gang_func" ].

ganske-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ganske_prd ] !>,
    FLAGS.TRIGGER "ganske_func" ].

garantert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED garantert_prd ] !>,
    FLAGS.TRIGGER "garantert_func" ].

gardimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gardimellom_prd ] !>,
    FLAGS.TRIGGER "gardimellom_func" ].

gatelangs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gatelangs_prd ] !>,
    FLAGS.TRIGGER "gatelangs_func" ].

generelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED generelt_prd ] !>,
    FLAGS.TRIGGER "generelt_func" ].

genuint-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED genuint_prd ] !>,
    FLAGS.TRIGGER "genuint_func" ].

gestapo-sjef-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gestapo-sjef_prd ] !>,
    FLAGS.TRIGGER "gestapo-sjef_func" ].

gid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gid_prd ] !>,
    FLAGS.TRIGGER "gid_func" ].

givetvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED givetvis_prd ] !>,
    FLAGS.TRIGGER "givetvis_func" ].

gjennom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gjennom_prd ] !>,
    FLAGS.TRIGGER "gjennom_func" ].

gjennomgående-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gjennomgående_prd ] !>,
    FLAGS.TRIGGER "gjennomgående_func" ].

gjerne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gjerne_prd ] !>,
    FLAGS.TRIGGER "gjerne_func" ].

gladelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gladelig_prd ] !>,
    FLAGS.TRIGGER "gladelig_func" ].

glimtvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED glimtvis_prd ] !>,
    FLAGS.TRIGGER "glimtvis_func" ].

glissando-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED glissando_prd ] !>,
    FLAGS.TRIGGER "glissando_func" ].

glugg-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED glugg_prd ] !>,
    FLAGS.TRIGGER "glugg_func" ].

glødende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED glødende_prd ] !>,
    FLAGS.TRIGGER "glødende_func" ].

gnistrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gnistrende_prd ] !>,
    FLAGS.TRIGGER "gnistrende_func" ].

godt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED godt_prd ] !>,
    FLAGS.TRIGGER "godt_func" ].

gorr-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gorr_prd ] !>,
    FLAGS.TRIGGER "gorr_func" ].

gorrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gorrende_prd ] !>,
    FLAGS.TRIGGER "gorrende_func" ].

gradvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gradvis_prd ] !>,
    FLAGS.TRIGGER "gradvis_func" ].

grandioso-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grandioso_prd ] !>,
    FLAGS.TRIGGER "grandioso_func" ].

granngivelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED granngivelig_prd ] !>,
    FLAGS.TRIGGER "granngivelig_func" ].

grassat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grassat_prd ] !>,
    FLAGS.TRIGGER "grassat_func" ].

gratis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gratis_prd ] !>,
    FLAGS.TRIGGER "gratis_func" ].

grav-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grav_prd ] !>,
    FLAGS.TRIGGER "grav_func" ].

grave-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grave_prd ] !>,
    FLAGS.TRIGGER "grave_func" ].

grenseløst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grenseløst_prd ] !>,
    FLAGS.TRIGGER "grenseløst_func" ].

gresselig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gresselig_prd ] !>,
    FLAGS.TRIGGER "gresselig_func" ].

grovt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grovt_prd ] !>,
    FLAGS.TRIGGER "grovt_func" ].

gruelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gruelig_prd ] !>,
    FLAGS.TRIGGER "gruelig_func" ].

grundig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grundig_prd ] !>,
    FLAGS.TRIGGER "grundig_func" ].

grunnet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grunnet_prd ] !>,
    FLAGS.TRIGGER "grunnet_func" ].

grunnleggende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grunnleggende_prd ] !>,
    FLAGS.TRIGGER "grunnleggende_func" ].

gruppevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gruppevis_prd ] !>,
    FLAGS.TRIGGER "gruppevis_func" ].

grusomt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grusomt_prd ] !>,
    FLAGS.TRIGGER "grusomt_func" ].

grådig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED grådig_prd ] !>,
    FLAGS.TRIGGER "grådig_func" ].

gudskjelov-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gudskjelov_prd ] !>,
    FLAGS.TRIGGER "gudskjelov_func" ].

gullende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gullende_prd ] !>,
    FLAGS.TRIGGER "gullende_func" ].

guttaktig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED guttaktig_prd ] !>,
    FLAGS.TRIGGER "guttaktig_func" ].

gyselig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gyselig_prd ] !>,
    FLAGS.TRIGGER "gyselig_func" ].

gørr-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gørr_prd ] !>,
    FLAGS.TRIGGER "gørr_func" ].

gørrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED gørrende_prd ] !>,
    FLAGS.TRIGGER "gørrende_func" ].

hakk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hakk_prd ] !>,
    FLAGS.TRIGGER "hakk_func" ].

hakkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hakkende_prd ] !>,
    FLAGS.TRIGGER "hakkende_func" ].

halvt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED halvt_prd ] !>,
    FLAGS.TRIGGER "halvt_func" ].

halvveges-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED halvveges_prd ] !>,
    FLAGS.TRIGGER "halvveges_func" ].

halvvegs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED halvvegs_prd ] !>,
    FLAGS.TRIGGER "halvvegs_func" ].

halvveis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED halvveis_prd ] !>,
    FLAGS.TRIGGER "halvveis_func" ].

hardt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hardt_prd ] !>,
    FLAGS.TRIGGER "hardt_func" ].

haugevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED haugevis_prd ] !>,
    FLAGS.TRIGGER "haugevis_func" ].

heden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heden_prd ] !>,
    FLAGS.TRIGGER "heden_func" ].

hefte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hefte_prd ] !>,
    FLAGS.TRIGGER "hefte_func" ].

heim-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heim_prd ] !>,
    FLAGS.TRIGGER "heim_func" ].

heima-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heima_prd ] !>,
    FLAGS.TRIGGER "heima_func" ].

heimafra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heimafra_prd ] !>,
    FLAGS.TRIGGER "heimafra_func" ].

heiman-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heiman_prd ] !>,
    FLAGS.TRIGGER "heiman_func" ].

heimanfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heimanfra_prd ] !>,
    FLAGS.TRIGGER "heimanfra_func" ].

heime-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heime_prd ] !>,
    FLAGS.TRIGGER "heime_func" ].

heimefra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heimefra_prd ] !>,
    FLAGS.TRIGGER "heimefra_func" ].

heimetter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heimetter_prd ] !>,
    FLAGS.TRIGGER "heimetter_func" ].

heimom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heimom_prd ] !>,
    FLAGS.TRIGGER "heimom_func" ].

heimover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heimover_prd ] !>,
    FLAGS.TRIGGER "heimover_func" ].

heldigvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heldigvis_prd ] !>,
    FLAGS.TRIGGER "heldigvis_func" ].

hele-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hele_prd ] !>,
    FLAGS.TRIGGER "hele_func" ].

heller*ikke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heller*ikke_prd ] !>,
    FLAGS.TRIGGER "heller*ikke_func" ].

heller-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heller_prd ] !>,
    FLAGS.TRIGGER "heller_func" ].

helst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED helst_prd ] !>,
    FLAGS.TRIGGER "helst_func" ].

helt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED helt_prd ] !>,
    FLAGS.TRIGGER "helt_func" ].

hen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hen_prd ] !>,
    FLAGS.TRIGGER "hen_func" ].

henholdsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED henholdsvis_prd ] !>,
    FLAGS.TRIGGER "henholdsvis_func" ].

henimot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED henimot_prd ] !>,
    FLAGS.TRIGGER "henimot_func" ].

henne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED henne_prd ] !>,
    FLAGS.TRIGGER "henne_func" ].

her*inne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her*inne_prd ] !>,
    FLAGS.TRIGGER "her*inne_func" ].

her*nede-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her*nede_prd ] !>,
    FLAGS.TRIGGER "her*nede_func" ].

her*og*der-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her*og*der_prd ] !>,
    FLAGS.TRIGGER "her*og*der_func" ].

her*og*nå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her*og*nå_prd ] !>,
    FLAGS.TRIGGER "her*og*nå_func" ].

her*oppe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her*oppe_prd ] !>,
    FLAGS.TRIGGER "her*oppe_func" ].

her*ute-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her*ute_prd ] !>,
    FLAGS.TRIGGER "her*ute_func" ].

her-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED her_prd ] !>,
    FLAGS.TRIGGER "her_func" ].

herav-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herav_prd ] !>,
    FLAGS.TRIGGER "herav_func" ].

heretter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heretter_prd ] !>,
    FLAGS.TRIGGER "heretter_func" ].

herfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herfra_prd ] !>,
    FLAGS.TRIGGER "herfra_func" ].

heri-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heri_prd ] !>,
    FLAGS.TRIGGER "heri_func" ].

heriblant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED heriblant_prd ] !>,
    FLAGS.TRIGGER "heriblant_func" ].

herifra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herifra_prd ] !>,
    FLAGS.TRIGGER "herifra_func" ].

herigjennom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herigjennom_prd ] !>,
    FLAGS.TRIGGER "herigjennom_func" ].

herimot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herimot_prd ] !>,
    FLAGS.TRIGGER "herimot_func" ].

herlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herlig_prd ] !>,
    FLAGS.TRIGGER "herlig_func" ].

hermed-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hermed_prd ] !>,
    FLAGS.TRIGGER "hermed_func" ].

herom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herom_prd ] !>,
    FLAGS.TRIGGER "herom_func" ].

herover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herover_prd ] !>,
    FLAGS.TRIGGER "herover_func" ].

herpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herpå_prd ] !>,
    FLAGS.TRIGGER "herpå_func" ].

herre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herre_prd ] !>,
    FLAGS.TRIGGER "herre_func" ].

hersens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hersens_prd ] !>,
    FLAGS.TRIGGER "hersens_func" ].

hertil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hertil_prd ] !>,
    FLAGS.TRIGGER "hertil_func" ].

herunder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herunder_prd ] !>,
    FLAGS.TRIGGER "herunder_func" ].

herved-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED herved_prd ] !>,
    FLAGS.TRIGGER "herved_func" ].

himla-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED himla_prd ] !>,
    FLAGS.TRIGGER "himla_func" ].

himlende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED himlende_prd ] !>,
    FLAGS.TRIGGER "himlende_func" ].

himmelropende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED himmelropende_prd ] !>,
    FLAGS.TRIGGER "himmelropende_func" ].

hisset-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hisset_prd ] !>,
    FLAGS.TRIGGER "hisset_func" ].

hist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hist_prd ] !>,
    FLAGS.TRIGGER "hist_func" ].

hit-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hit_prd ] !>,
    FLAGS.TRIGGER "hit_func" ].

hitover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hitover_prd ] !>,
    FLAGS.TRIGGER "hitover_func" ].

hittil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hittil_prd ] !>,
    FLAGS.TRIGGER "hittil_func" ].

hjelpeløst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjelpeløst_prd ] !>,
    FLAGS.TRIGGER "hjelpeløst_func" ].

hjem-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjem_prd ] !>,
    FLAGS.TRIGGER "hjem_func" ].

hjemad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjemad_prd ] !>,
    FLAGS.TRIGGER "hjemad_func" ].

hjemetter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjemetter_prd ] !>,
    FLAGS.TRIGGER "hjemetter_func" ].

hjemme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjemme_prd ] !>,
    FLAGS.TRIGGER "hjemme_func" ].

hjemmefra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjemmefra_prd ] !>,
    FLAGS.TRIGGER "hjemmefra_func" ].

hjemom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjemom_prd ] !>,
    FLAGS.TRIGGER "hjemom_func" ].

hjemover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hjemover_prd ] !>,
    FLAGS.TRIGGER "hjemover_func" ].

hodekulls-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hodekulls_prd ] !>,
    FLAGS.TRIGGER "hodekulls_func" ].

hodestupes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hodestupes_prd ] !>,
    FLAGS.TRIGGER "hodestupes_func" ].

hodestups-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hodestups_prd ] !>,
    FLAGS.TRIGGER "hodestups_func" ].

hoggende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hoggende_prd ] !>,
    FLAGS.TRIGGER "hoggende_func" ].

hollywood-kollega-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hollywood-kollega_prd ] !>,
    FLAGS.TRIGGER "hollywood-kollega_func" ].

hoppende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hoppende_prd ] !>,
    FLAGS.TRIGGER "hoppende_func" ].

hos-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hos_prd ] !>,
    FLAGS.TRIGGER "hos_func" ].

hrperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hrperiod_prd ] !>,
    FLAGS.TRIGGER "hrperiod_func" ].

hulter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hulter_prd ] !>,
    FLAGS.TRIGGER "hulter_func" ].

hundre*prosent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hundre*prosent_prd ] !>,
    FLAGS.TRIGGER "hundre*prosent_func" ].

hundretusenvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hundretusenvis_prd ] !>,
    FLAGS.TRIGGER "hundretusenvis_func" ].

hundrevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hundrevis_prd ] !>,
    FLAGS.TRIGGER "hundrevis_func" ].

hurra-meg-rundt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hurra-meg-rundt_prd ] !>,
    FLAGS.TRIGGER "hurra-meg-rundt_func" ].

husimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED husimellom_prd ] !>,
    FLAGS.TRIGGER "husimellom_func" ].

hvi-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvi_prd ] !>,
    FLAGS.TRIGGER "hvi_func" ].

hvis*mulig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvis*mulig_prd ] !>,
    FLAGS.TRIGGER "hvis*mulig_func" ].

hvis*nødvendig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvis*nødvendig_prd ] !>,
    FLAGS.TRIGGER "hvis*nødvendig_func" ].

hvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvis_prd ] !>,
    FLAGS.TRIGGER "hvis_func" ].

hvisomatte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvisomatte_prd ] !>,
    FLAGS.TRIGGER "hvisomatte_func" ].

hvor*som*helst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvor*som*helst_prd ] !>,
    FLAGS.TRIGGER "hvor*som*helst_func" ].

hvor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvor_prd ] !>,
    FLAGS.TRIGGER "hvor_func" ].

hvorav-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorav_prd ] !>,
    FLAGS.TRIGGER "hvorav_func" ].

hvordan-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvordan_prd ] !>,
    FLAGS.TRIGGER "hvordan_func" ].

hvoretter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvoretter_prd ] !>,
    FLAGS.TRIGGER "hvoretter_func" ].

hvorfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorfor_prd ] !>,
    FLAGS.TRIGGER "hvorfor_func" ].

hvorfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorfra_prd ] !>,
    FLAGS.TRIGGER "hvorfra_func" ].

hvori-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvori_prd ] !>,
    FLAGS.TRIGGER "hvori_func" ].

hvoriblant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvoriblant_prd ] !>,
    FLAGS.TRIGGER "hvoriblant_func" ].

hvorimot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorimot_prd ] !>,
    FLAGS.TRIGGER "hvorimot_func" ].

hvorledes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorledes_prd ] !>,
    FLAGS.TRIGGER "hvorledes_func" ].

hvormed-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvormed_prd ] !>,
    FLAGS.TRIGGER "hvormed_func" ].

hvorom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorom_prd ] !>,
    FLAGS.TRIGGER "hvorom_func" ].

hvorpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hvorpå_prd ] !>,
    FLAGS.TRIGGER "hvorpå_func" ].

hånt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hånt_prd ] !>,
    FLAGS.TRIGGER "hånt_func" ].

håpløst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED håpløst_prd ] !>,
    FLAGS.TRIGGER "håpløst_func" ].

hårreisende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED hårreisende_prd ] !>,
    FLAGS.TRIGGER "hårreisende_func" ].

høylig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED høylig_prd ] !>,
    FLAGS.TRIGGER "høylig_func" ].

høyre-leder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED høyre-leder_prd ] !>,
    FLAGS.TRIGGER "høyre-leder_func" ].

høyst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED høyst_prd ] !>,
    FLAGS.TRIGGER "høyst_func" ].

høyt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED høyt_prd ] !>,
    FLAGS.TRIGGER "høyt_func" ].

i*aften-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*aften_prd ] !>,
    FLAGS.TRIGGER "i*aften_func" ].

i*aftes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*aftes_prd ] !>,
    FLAGS.TRIGGER "i*aftes_func" ].

i*alle*fall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*alle*fall_prd ] !>,
    FLAGS.TRIGGER "i*alle*fall_func" ].

i*alt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*alt_prd ] !>,
    FLAGS.TRIGGER "i*alt_func" ].

i*anledning-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*anledning_prd ] !>,
    FLAGS.TRIGGER "i*anledning_func" ].

i*beste*velgående-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*beste*velgående_prd ] !>,
    FLAGS.TRIGGER "i*beste*velgående_func" ].

i*bunn*og*grunn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*bunn*og*grunn_prd ] !>,
    FLAGS.TRIGGER "i*bunn*og*grunn_func" ].

i*dag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*dag_prd ] !>,
    FLAGS.TRIGGER "i*dag_func" ].

i*dagevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*dagevis_prd ] !>,
    FLAGS.TRIGGER "i*dagevis_func" ].

i*det*hele*tatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*det*hele*tatt_prd ] !>,
    FLAGS.TRIGGER "i*det*hele*tatt_func" ].

i*det*samme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*det*samme_prd ] !>,
    FLAGS.TRIGGER "i*det*samme_func" ].

i*det*siste-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*det*siste_prd ] !>,
    FLAGS.TRIGGER "i*det*siste_func" ].

i*det-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*det_prd ] !>,
    FLAGS.TRIGGER "i*det_func" ].

i*drømme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*drømme_prd ] !>,
    FLAGS.TRIGGER "i*drømme_func" ].

i*egenskap*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*egenskap*av_prd ] !>,
    FLAGS.TRIGGER "i*egenskap*av_func" ].

i*ett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*ett_prd ] !>,
    FLAGS.TRIGGER "i*ett_func" ].

i*etterkant*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*etterkant*av_prd ] !>,
    FLAGS.TRIGGER "i*etterkant*av_func" ].

i*ferd*med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*ferd*med_prd ] !>,
    FLAGS.TRIGGER "i*ferd*med_func" ].

i*fjor*høst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fjor*høst_prd ] !>,
    FLAGS.TRIGGER "i*fjor*høst_func" ].

i*fjor*sommer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fjor*sommer_prd ] !>,
    FLAGS.TRIGGER "i*fjor*sommer_func" ].

i*fjor*vinter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fjor*vinter_prd ] !>,
    FLAGS.TRIGGER "i*fjor*vinter_func" ].

i*fjor*vår-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fjor*vår_prd ] !>,
    FLAGS.TRIGGER "i*fjor*vår_func" ].

i*fjor*våres-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fjor*våres_prd ] !>,
    FLAGS.TRIGGER "i*fjor*våres_func" ].

i*fjor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fjor_prd ] !>,
    FLAGS.TRIGGER "i*fjor_func" ].

i*forbindelse*med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forbindelse*med_prd ] !>,
    FLAGS.TRIGGER "i*forbindelse*med_func" ].

i*forfjor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forfjor_prd ] !>,
    FLAGS.TRIGGER "i*forfjor_func" ].

i*forgårs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forgårs_prd ] !>,
    FLAGS.TRIGGER "i*forgårs_func" ].

i*forkant*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forkant*av_prd ] !>,
    FLAGS.TRIGGER "i*forkant*av_func" ].

i*forkant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forkant_prd ] !>,
    FLAGS.TRIGGER "i*forkant_func" ].

i*forkjøpet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forkjøpet_prd ] !>,
    FLAGS.TRIGGER "i*forkjøpet_func" ].

i*form*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*form*av_prd ] !>,
    FLAGS.TRIGGER "i*form*av_func" ].

i*forveien-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*forveien_prd ] !>,
    FLAGS.TRIGGER "i*forveien_func" ].

i*fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*fra_prd ] !>,
    FLAGS.TRIGGER "i*fra_func" ].

i*følge-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*følge_prd ] !>,
    FLAGS.TRIGGER "i*følge_func" ].

i*gamledager-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*gamledager_prd ] !>,
    FLAGS.TRIGGER "i*gamledager_func" ].

i*gang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*gang_prd ] !>,
    FLAGS.TRIGGER "i*gang_func" ].

i*grunnen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*grunnen_prd ] !>,
    FLAGS.TRIGGER "i*grunnen_func" ].

i*går*ettermiddag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*går*ettermiddag_prd ] !>,
    FLAGS.TRIGGER "i*går*ettermiddag_func" ].

i*går*kveld-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*går*kveld_prd ] !>,
    FLAGS.TRIGGER "i*går*kveld_func" ].

i*går-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*går_prd ] !>,
    FLAGS.TRIGGER "i*går_func" ].

i*henhold*til-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*henhold*til_prd ] !>,
    FLAGS.TRIGGER "i*henhold*til_func" ].

i*hop-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*hop_prd ] !>,
    FLAGS.TRIGGER "i*hop_func" ].

i*hvert*fall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*hvert*fall_prd ] !>,
    FLAGS.TRIGGER "i*hvert*fall_func" ].

i*kraft-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*kraft_prd ] !>,
    FLAGS.TRIGGER "i*kraft_func" ].

i*kveld-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*kveld_prd ] !>,
    FLAGS.TRIGGER "i*kveld_func" ].

i*le-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*le_prd ] !>,
    FLAGS.TRIGGER "i*le_func" ].

i*løpet*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*løpet*av_prd ] !>,
    FLAGS.TRIGGER "i*løpet*av_func" ].

i*massevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*massevis_prd ] !>,
    FLAGS.TRIGGER "i*massevis_func" ].

i*mellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*mellom_prd ] !>,
    FLAGS.TRIGGER "i*mellom_func" ].

i*mellomtiden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*mellomtiden_prd ] !>,
    FLAGS.TRIGGER "i*mellomtiden_func" ].

i*morgen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*morgen_prd ] !>,
    FLAGS.TRIGGER "i*morgen_func" ].

i*mot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*mot_prd ] !>,
    FLAGS.TRIGGER "i*mot_func" ].

i*munnen*på-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*munnen*på_prd ] !>,
    FLAGS.TRIGGER "i*munnen*på_func" ].

i*månedsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*månedsvis_prd ] !>,
    FLAGS.TRIGGER "i*månedsvis_func" ].

i*nærheten*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*nærheten*av_prd ] !>,
    FLAGS.TRIGGER "i*nærheten*av_func" ].

i*overkant*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*overkant*av_prd ] !>,
    FLAGS.TRIGGER "i*overkant*av_func" ].

i*overmorgen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*overmorgen_prd ] !>,
    FLAGS.TRIGGER "i*overmorgen_func" ].

i*retning-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*retning_prd ] !>,
    FLAGS.TRIGGER "i*retning_func" ].

i*seg*selv-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*seg*selv_prd ] !>,
    FLAGS.TRIGGER "i*seg*selv_func" ].

i*seg*sjøl-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*seg*sjøl_prd ] !>,
    FLAGS.TRIGGER "i*seg*sjøl_func" ].

i*stand-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*stand_prd ] !>,
    FLAGS.TRIGGER "i*stand_func" ].

i*steden*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*steden*for_prd ] !>,
    FLAGS.TRIGGER "i*steden*for_func" ].

i*stedet*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*stedet*for_prd ] !>,
    FLAGS.TRIGGER "i*stedet*for_func" ].

i*stor*grad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*stor*grad_prd ] !>,
    FLAGS.TRIGGER "i*stor*grad_func" ].

i*stykker-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*stykker_prd ] !>,
    FLAGS.TRIGGER "i*stykker_func" ].

i*så*fall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*så*fall_prd ] !>,
    FLAGS.TRIGGER "i*så*fall_func" ].

i*tilfelle-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*tilfelle_prd ] !>,
    FLAGS.TRIGGER "i*tilfelle_func" ].

i*tillegg*til-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*tillegg*til_prd ] !>,
    FLAGS.TRIGGER "i*tillegg*til_func" ].

i*timevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*timevis_prd ] !>,
    FLAGS.TRIGGER "i*timevis_func" ].

i*vei-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*vei_prd ] !>,
    FLAGS.TRIGGER "i*vei_func" ].

i*verk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*verk_prd ] !>,
    FLAGS.TRIGGER "i*verk_func" ].

i*år-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*år_prd ] !>,
    FLAGS.TRIGGER "i*år_func" ].

i*årevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i*årevis_prd ] !>,
    FLAGS.TRIGGER "i*årevis_func" ].

i-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED i_prd ] !>,
    FLAGS.TRIGGER "i_func" ].

iallfall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED iallfall_prd ] !>,
    FLAGS.TRIGGER "iallfall_func" ].

ialt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ialt_prd ] !>,
    FLAGS.TRIGGER "ialt_func" ].

ibidem-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ibidem_prd ] !>,
    FLAGS.TRIGGER "ibidem_func" ].

iblant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED iblant_prd ] !>,
    FLAGS.TRIGGER "iblant_func" ].

idag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED idag_prd ] !>,
    FLAGS.TRIGGER "idag_func" ].

idet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED idet_prd ] !>,
    FLAGS.TRIGGER "idet_func" ].

ifall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ifall_prd ] !>,
    FLAGS.TRIGGER "ifall_func" ].

ifra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ifra_prd ] !>,
    FLAGS.TRIGGER "ifra_func" ].

ifølge-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ifølge_prd ] !>,
    FLAGS.TRIGGER "ifølge_func" ].

igang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED igang_prd ] !>,
    FLAGS.TRIGGER "igang_func" ].

igjen*og*igjen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED igjen*og*igjen_prd ] !>,
    FLAGS.TRIGGER "igjen*og*igjen_func" ].

igjen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED igjen_prd ] !>,
    FLAGS.TRIGGER "igjen_func" ].

igjennom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED igjennom_prd ] !>,
    FLAGS.TRIGGER "igjennom_func" ].

igrunnen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED igrunnen_prd ] !>,
    FLAGS.TRIGGER "igrunnen_func" ].

igår-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED igår_prd ] !>,
    FLAGS.TRIGGER "igår_func" ].

ihvertfall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ihvertfall_prd ] !>,
    FLAGS.TRIGGER "ihvertfall_func" ].

ikke*minst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ikke*minst_prd ] !>,
    FLAGS.TRIGGER "ikke*minst_func" ].

ikke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ikke_prd ] !>,
    FLAGS.TRIGGER "ikke_func" ].

ikveld-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ikveld_prd ] !>,
    FLAGS.TRIGGER "ikveld_func" ].

ildende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ildende_prd ] !>,
    FLAGS.TRIGGER "ildende_func" ].

ille-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ille_prd ] !>,
    FLAGS.TRIGGER "ille_func" ].

imellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED imellom_prd ] !>,
    FLAGS.TRIGGER "imellom_func" ].

imens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED imens_prd ] !>,
    FLAGS.TRIGGER "imens_func" ].

imidlertid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED imidlertid_prd ] !>,
    FLAGS.TRIGGER "imidlertid_func" ].

imorgen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED imorgen_prd ] !>,
    FLAGS.TRIGGER "imorgen_func" ].

imot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED imot_prd ] !>,
    FLAGS.TRIGGER "imot_func" ].

inderlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inderlig_prd ] !>,
    FLAGS.TRIGGER "inderlig_func" ].

ingenlunde-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ingenlunde_prd ] !>,
    FLAGS.TRIGGER "ingenlunde_func" ].

ingensteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ingensteds_prd ] !>,
    FLAGS.TRIGGER "ingensteds_func" ].

ingenting-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ingenting_prd ] !>,
    FLAGS.TRIGGER "ingenting_func" ].

inkludert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inkludert_prd ] !>,
    FLAGS.TRIGGER "inkludert_func" ].

inklusiv-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inklusiv_prd ] !>,
    FLAGS.TRIGGER "inklusiv_func" ].

inklusive-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inklusive_prd ] !>,
    FLAGS.TRIGGER "inklusive_func" ].

inkognito-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inkognito_prd ] !>,
    FLAGS.TRIGGER "inkognito_func" ].

inn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inn_prd ] !>,
    FLAGS.TRIGGER "inn_func" ].

innad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innad_prd ] !>,
    FLAGS.TRIGGER "innad_func" ].

innafor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innafor_prd ] !>,
    FLAGS.TRIGGER "innafor_func" ].

innafra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innafra_prd ] !>,
    FLAGS.TRIGGER "innafra_func" ].

innalands-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innalands_prd ] !>,
    FLAGS.TRIGGER "innalands_func" ].

innaskjærs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innaskjærs_prd ] !>,
    FLAGS.TRIGGER "innaskjærs_func" ].

inne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inne_prd ] !>,
    FLAGS.TRIGGER "inne_func" ].

innefra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innefra_prd ] !>,
    FLAGS.TRIGGER "innefra_func" ].

innen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innen_prd ] !>,
    FLAGS.TRIGGER "innen_func" ].

innenat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innenat_prd ] !>,
    FLAGS.TRIGGER "innenat_func" ].

innenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innenfor_prd ] !>,
    FLAGS.TRIGGER "innenfor_func" ].

innenfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innenfra_prd ] !>,
    FLAGS.TRIGGER "innenfra_func" ].

innenifra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innenifra_prd ] !>,
    FLAGS.TRIGGER "innenifra_func" ].

innenlands-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innenlands_prd ] !>,
    FLAGS.TRIGGER "innenlands_func" ].

innenskjærs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innenskjærs_prd ] !>,
    FLAGS.TRIGGER "innenskjærs_func" ].

innerst*inne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innerst*inne_prd ] !>,
    FLAGS.TRIGGER "innerst*inne_func" ].

innerst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innerst_prd ] !>,
    FLAGS.TRIGGER "innerst_func" ].

inni-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inni_prd ] !>,
    FLAGS.TRIGGER "inni_func" ].

innimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innimellom_prd ] !>,
    FLAGS.TRIGGER "innimellom_func" ].

innledningsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innledningsvis_prd ] !>,
    FLAGS.TRIGGER "innledningsvis_func" ].

innleiingsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innleiingsvis_prd ] !>,
    FLAGS.TRIGGER "innleiingsvis_func" ].

innmari-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innmari_prd ] !>,
    FLAGS.TRIGGER "innmari_func" ].

innom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innom_prd ] !>,
    FLAGS.TRIGGER "innom_func" ].

innomhus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innomhus_prd ] !>,
    FLAGS.TRIGGER "innomhus_func" ].

innover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innover_prd ] !>,
    FLAGS.TRIGGER "innover_func" ].

innpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innpå_prd ] !>,
    FLAGS.TRIGGER "innpå_func" ].

inntil*videre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inntil*videre_prd ] !>,
    FLAGS.TRIGGER "inntil*videre_func" ].

inntil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED inntil_prd ] !>,
    FLAGS.TRIGGER "inntil_func" ].

innunder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED innunder_prd ] !>,
    FLAGS.TRIGGER "innunder_func" ].

intenst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED intenst_prd ] !>,
    FLAGS.TRIGGER "intenst_func" ].

internasjonalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED internasjonalt_prd ] !>,
    FLAGS.TRIGGER "internasjonalt_func" ].

irrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED irrende_prd ] !>,
    FLAGS.TRIGGER "irrende_func" ].

irriterende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED irriterende_prd ] !>,
    FLAGS.TRIGGER "irriterende_func" ].

isende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED isende_prd ] !>,
    FLAGS.TRIGGER "isende_func" ].

isteden*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED isteden*for_prd ] !>,
    FLAGS.TRIGGER "isteden*for_func" ].

isteden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED isteden_prd ] !>,
    FLAGS.TRIGGER "isteden_func" ].

istedenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED istedenfor_prd ] !>,
    FLAGS.TRIGGER "istedenfor_func" ].

istedet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED istedet_prd ] !>,
    FLAGS.TRIGGER "istedet_func" ].

istykker-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED istykker_prd ] !>,
    FLAGS.TRIGGER "istykker_func" ].

især-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED især_prd ] !>,
    FLAGS.TRIGGER "især_func" ].

item-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED item_prd ] !>,
    FLAGS.TRIGGER "item_func" ].

ivei-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ivei_prd ] !>,
    FLAGS.TRIGGER "ivei_func" ].

iøynefallende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED iøynefallende_prd ] !>,
    FLAGS.TRIGGER "iøynefallende_func" ].

ja-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ja_prd ] !>,
    FLAGS.TRIGGER "ja_func" ].

jamen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jamen_prd ] !>,
    FLAGS.TRIGGER "jamen_func" ].

jammen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jammen_prd ] !>,
    FLAGS.TRIGGER "jammen_func" ].

jamnlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jamnlig_prd ] !>,
    FLAGS.TRIGGER "jamnlig_func" ].

jamsides-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jamsides_prd ] !>,
    FLAGS.TRIGGER "jamsides_func" ].

jamvel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jamvel_prd ] !>,
    FLAGS.TRIGGER "jamvel_func" ].

jaså-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jaså_prd ] !>,
    FLAGS.TRIGGER "jaså_func" ].

jevnlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jevnlig_prd ] !>,
    FLAGS.TRIGGER "jevnlig_func" ].

jevnsides-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jevnsides_prd ] !>,
    FLAGS.TRIGGER "jevnsides_func" ].

jevnt*og*trutt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jevnt*og*trutt_prd ] !>,
    FLAGS.TRIGGER "jevnt*og*trutt_func" ].

jevnt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jevnt_prd ] !>,
    FLAGS.TRIGGER "jevnt_func" ].

jo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jo_prd ] !>,
    FLAGS.TRIGGER "jo_func" ].

jomfru-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jomfru_prd ] !>,
    FLAGS.TRIGGER "jomfru_func" ].

jommen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jommen_prd ] !>,
    FLAGS.TRIGGER "jommen_func" ].

jublende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jublende_prd ] !>,
    FLAGS.TRIGGER "jublende_func" ].

just-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED just_prd ] !>,
    FLAGS.TRIGGER "just_func" ].

jækla-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jækla_prd ] !>,
    FLAGS.TRIGGER "jækla_func" ].

jævla-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jævla_prd ] !>,
    FLAGS.TRIGGER "jævla_func" ].

jævlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED jævlig_prd ] !>,
    FLAGS.TRIGGER "jævlig_func" ].

kanon-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kanon_prd ] !>,
    FLAGS.TRIGGER "kanon_func" ].

kanskje-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kanskje_prd ] !>,
    FLAGS.TRIGGER "kanskje_func" ].

kapperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kapperiod_prd ] !>,
    FLAGS.TRIGGER "kapperiod_func" ].

kartleser-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kartleser_prd ] !>,
    FLAGS.TRIGGER "kartleser_func" ].

kav-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kav_prd ] !>,
    FLAGS.TRIGGER "kav_func" ].

kavende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kavende_prd ] !>,
    FLAGS.TRIGGER "kavende_func" ].

kilovis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kilovis_prd ] !>,
    FLAGS.TRIGGER "kilovis_func" ].

klart-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED klart_prd ] !>,
    FLAGS.TRIGGER "klart_func" ].

klin-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED klin_prd ] !>,
    FLAGS.TRIGGER "klin_func" ].

klink-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED klink_prd ] !>,
    FLAGS.TRIGGER "klink_func" ].

klinkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED klinkende_prd ] !>,
    FLAGS.TRIGGER "klinkende_func" ].

kliss-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kliss_prd ] !>,
    FLAGS.TRIGGER "kliss_func" ].

klissende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED klissende_prd ] !>,
    FLAGS.TRIGGER "klissende_func" ].

klokelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED klokelig_prd ] !>,
    FLAGS.TRIGGER "klokelig_func" ].

knakende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knakende_prd ] !>,
    FLAGS.TRIGGER "knakende_func" ].

knall-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knall_prd ] !>,
    FLAGS.TRIGGER "knall_func" ].

knallende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knallende_prd ] !>,
    FLAGS.TRIGGER "knallende_func" ].

knappe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knappe_prd ] !>,
    FLAGS.TRIGGER "knappe_func" ].

knapt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knapt_prd ] !>,
    FLAGS.TRIGGER "knapt_func" ].

knasende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knasende_prd ] !>,
    FLAGS.TRIGGER "knasende_func" ].

knekkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knekkende_prd ] !>,
    FLAGS.TRIGGER "knekkende_func" ].

knøtrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knøtrende_prd ] !>,
    FLAGS.TRIGGER "knøtrende_func" ].

knøtt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knøtt_prd ] !>,
    FLAGS.TRIGGER "knøtt_func" ].

knøttende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED knøttende_prd ] !>,
    FLAGS.TRIGGER "knøttende_func" ].

kolende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kolende_prd ] !>,
    FLAGS.TRIGGER "kolende_func" ].

kommersielt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kommersielt_prd ] !>,
    FLAGS.TRIGGER "kommersielt_func" ].

komplett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED komplett_prd ] !>,
    FLAGS.TRIGGER "komplett_func" ].

kong-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kong_prd ] !>,
    FLAGS.TRIGGER "kong_func" ].

konstant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED konstant_prd ] !>,
    FLAGS.TRIGGER "konstant_func" ].

kor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kor_prd ] !>,
    FLAGS.TRIGGER "kor_func" ].

korfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED korfor_prd ] !>,
    FLAGS.TRIGGER "korfor_func" ].

kort*og*godt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kort*og*godt_prd ] !>,
    FLAGS.TRIGGER "kort*og*godt_func" ].

kort-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kort_prd ] !>,
    FLAGS.TRIGGER "kort_func" ].

kritt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kritt_prd ] !>,
    FLAGS.TRIGGER "kritt_func" ].

krittende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED krittende_prd ] !>,
    FLAGS.TRIGGER "krittende_func" ].

kul-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kul_prd ] !>,
    FLAGS.TRIGGER "kul_func" ].

kuli-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kuli_prd ] !>,
    FLAGS.TRIGGER "kuli_func" ].

kullende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kullende_prd ] !>,
    FLAGS.TRIGGER "kullende_func" ].

kulturelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kulturelt_prd ] !>,
    FLAGS.TRIGGER "kulturelt_func" ].

kun-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kun_prd ] !>,
    FLAGS.TRIGGER "kun_func" ].

kvalitativt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kvalitativt_prd ] !>,
    FLAGS.TRIGGER "kvalitativt_func" ].

kvalmende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kvalmende_prd ] !>,
    FLAGS.TRIGGER "kvalmende_func" ].

kvartalsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kvartalsvis_prd ] !>,
    FLAGS.TRIGGER "kvartalsvis_func" ].

kvekk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kvekk_prd ] !>,
    FLAGS.TRIGGER "kvekk_func" ].

kvelende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kvelende_prd ] !>,
    FLAGS.TRIGGER "kvelende_func" ].

kølende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED kølende_prd ] !>,
    FLAGS.TRIGGER "kølende_func" ].

lady-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lady_prd ] !>,
    FLAGS.TRIGGER "lady_func" ].

lag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lag_prd ] !>,
    FLAGS.TRIGGER "lag_func" ].

lagerfritt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lagerfritt_prd ] !>,
    FLAGS.TRIGGER "lagerfritt_func" ].

lagom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lagom_prd ] !>,
    FLAGS.TRIGGER "lagom_func" ].

lagvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lagvis_prd ] !>,
    FLAGS.TRIGGER "lagvis_func" ].

landimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED landimellom_prd ] !>,
    FLAGS.TRIGGER "landimellom_func" ].

landverts-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED landverts_prd ] !>,
    FLAGS.TRIGGER "landverts_func" ].

langs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langs_prd ] !>,
    FLAGS.TRIGGER "langs_func" ].

langsmed-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langsmed_prd ] !>,
    FLAGS.TRIGGER "langsmed_func" ].

langt*fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langt*fra_prd ] !>,
    FLAGS.TRIGGER "langt*fra_func" ].

langt*om*lenge-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langt*om*lenge_prd ] !>,
    FLAGS.TRIGGER "langt*om*lenge_func" ].

langt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langt_prd ] !>,
    FLAGS.TRIGGER "langt_func" ].

langtfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langtfra_prd ] !>,
    FLAGS.TRIGGER "langtfra_func" ].

langveges-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langveges_prd ] !>,
    FLAGS.TRIGGER "langveges_func" ].

langvegesfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langvegesfra_prd ] !>,
    FLAGS.TRIGGER "langvegesfra_func" ].

langvegs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langvegs_prd ] !>,
    FLAGS.TRIGGER "langvegs_func" ].

langvegsfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langvegsfra_prd ] !>,
    FLAGS.TRIGGER "langvegsfra_func" ].

langveis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langveis_prd ] !>,
    FLAGS.TRIGGER "langveis_func" ].

langveisfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED langveisfra_prd ] !>,
    FLAGS.TRIGGER "langveisfra_func" ].

larghetto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED larghetto_prd ] !>,
    FLAGS.TRIGGER "larghetto_func" ].

largo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED largo_prd ] !>,
    FLAGS.TRIGGER "largo_func" ].

lassevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lassevis_prd ] !>,
    FLAGS.TRIGGER "lassevis_func" ].

latterlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED latterlig_prd ] !>,
    FLAGS.TRIGGER "latterlig_func" ].

leder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED leder_prd ] !>,
    FLAGS.TRIGGER "leder_func" ].

legato-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED legato_prd ] !>,
    FLAGS.TRIGGER "legato_func" ].

leilighetsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED leilighetsvis_prd ] !>,
    FLAGS.TRIGGER "leilighetsvis_func" ].

lell-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lell_prd ] !>,
    FLAGS.TRIGGER "lell_func" ].

lenge*og*vel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lenge*og*vel_prd ] !>,
    FLAGS.TRIGGER "lenge*og*vel_func" ].

lenge*oppe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lenge*oppe_prd ] !>,
    FLAGS.TRIGGER "lenge*oppe_func" ].

lenge-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lenge_prd ] !>,
    FLAGS.TRIGGER "lenge_func" ].

lenger-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lenger_prd ] !>,
    FLAGS.TRIGGER "lenger_func" ].

lengre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lengre_prd ] !>,
    FLAGS.TRIGGER "lengre_func" ].

lengst*mulig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lengst*mulig_prd ] !>,
    FLAGS.TRIGGER "lengst*mulig_func" ].

lett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lett_prd ] !>,
    FLAGS.TRIGGER "lett_func" ].

lettere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lettere_prd ] !>,
    FLAGS.TRIGGER "lettere_func" ].

liddelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED liddelig_prd ] !>,
    FLAGS.TRIGGER "liddelig_func" ].

like*ved-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED like*ved_prd ] !>,
    FLAGS.TRIGGER "like*ved_func" ].

like-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED like_prd ] !>,
    FLAGS.TRIGGER "like_func" ].

likefullt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED likefullt_prd ] !>,
    FLAGS.TRIGGER "likefullt_func" ].

likeledes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED likeledes_prd ] !>,
    FLAGS.TRIGGER "likeledes_func" ].

likesom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED likesom_prd ] !>,
    FLAGS.TRIGGER "likesom_func" ].

likeså-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED likeså_prd ] !>,
    FLAGS.TRIGGER "likeså_func" ].

likevel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED likevel_prd ] !>,
    FLAGS.TRIGGER "likevel_func" ].

liksom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED liksom_prd ] !>,
    FLAGS.TRIGGER "liksom_func" ].

likså-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED likså_prd ] !>,
    FLAGS.TRIGGER "likså_func" ].

lissom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lissom_prd ] !>,
    FLAGS.TRIGGER "lissom_func" ].

lite-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lite_prd ] !>,
    FLAGS.TRIGGER "lite_func" ].

litegrann-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED litegrann_prd ] !>,
    FLAGS.TRIGGER "litegrann_func" ].

litervis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED litervis_prd ] !>,
    FLAGS.TRIGGER "litervis_func" ].

litt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED litt_prd ] !>,
    FLAGS.TRIGGER "litt_func" ].

livende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED livende_prd ] !>,
    FLAGS.TRIGGER "livende_func" ].

lord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lord_prd ] !>,
    FLAGS.TRIGGER "lord_func" ].

lovlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lovlig_prd ] !>,
    FLAGS.TRIGGER "lovlig_func" ].

lukt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lukt_prd ] !>,
    FLAGS.TRIGGER "lukt_func" ].

lut-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lut_prd ] !>,
    FLAGS.TRIGGER "lut_func" ].

luta-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED luta_prd ] !>,
    FLAGS.TRIGGER "luta_func" ].

lutende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lutende_prd ] !>,
    FLAGS.TRIGGER "lutende_func" ].

lykkeligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lykkeligvis_prd ] !>,
    FLAGS.TRIGGER "lykkeligvis_func" ].

lynende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lynende_prd ] !>,
    FLAGS.TRIGGER "lynende_func" ].

lys-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lys_prd ] !>,
    FLAGS.TRIGGER "lys_func" ].

lysende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED lysende_prd ] !>,
    FLAGS.TRIGGER "lysende_func" ].

løs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED løs_prd ] !>,
    FLAGS.TRIGGER "løs_func" ].

m*slash*b-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED m*slash*b_prd ] !>,
    FLAGS.TRIGGER "m*slash*b_func" ].

madam-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED madam_prd ] !>,
    FLAGS.TRIGGER "madam_func" ].

maestoso-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED maestoso_prd ] !>,
    FLAGS.TRIGGER "maestoso_func" ].

maksimalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED maksimalt_prd ] !>,
    FLAGS.TRIGGER "maksimalt_func" ].

malapropos-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED malapropos_prd ] !>,
    FLAGS.TRIGGER "malapropos_func" ].

mange-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mange_prd ] !>,
    FLAGS.TRIGGER "mange_func" ].

mannemellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mannemellom_prd ] !>,
    FLAGS.TRIGGER "mannemellom_func" ].

markant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED markant_prd ] !>,
    FLAGS.TRIGGER "markant_func" ].

markert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED markert_prd ] !>,
    FLAGS.TRIGGER "markert_func" ].

massevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED massevis_prd ] !>,
    FLAGS.TRIGGER "massevis_func" ].

matros-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED matros_prd ] !>,
    FLAGS.TRIGGER "matros_func" ].

med*andre*ord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med*andre*ord_prd ] !>,
    FLAGS.TRIGGER "med*andre*ord_func" ].

med*det*samme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med*det*samme_prd ] !>,
    FLAGS.TRIGGER "med*det*samme_func" ].

med*en*gang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med*en*gang_prd ] !>,
    FLAGS.TRIGGER "med*en*gang_func" ].

med*ett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med*ett_prd ] !>,
    FLAGS.TRIGGER "med*ett_func" ].

med*mindre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med*mindre_prd ] !>,
    FLAGS.TRIGGER "med*mindre_func" ].

med*én*gang-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med*én*gang_prd ] !>,
    FLAGS.TRIGGER "med*én*gang_func" ].

med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED med_prd ] !>,
    FLAGS.TRIGGER "med_func" ].

medio-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED medio_prd ] !>,
    FLAGS.TRIGGER "medio_func" ].

medium-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED medium_prd ] !>,
    FLAGS.TRIGGER "medium_func" ].

medmindre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED medmindre_prd ] !>,
    FLAGS.TRIGGER "medmindre_func" ].

medregnet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED medregnet_prd ] !>,
    FLAGS.TRIGGER "medregnet_func" ].

medsols-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED medsols_prd ] !>,
    FLAGS.TRIGGER "medsols_func" ].

medstrøms-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED medstrøms_prd ] !>,
    FLAGS.TRIGGER "medstrøms_func" ].

meget-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED meget_prd ] !>,
    FLAGS.TRIGGER "meget_func" ].

mellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mellom_prd ] !>,
    FLAGS.TRIGGER "mellom_func" ].

mengdevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mengdevis_prd ] !>,
    FLAGS.TRIGGER "mengdevis_func" ].

mens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mens_prd ] !>,
    FLAGS.TRIGGER "mens_func" ].

mer*eller*mindre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mer*eller*mindre_prd ] !>,
    FLAGS.TRIGGER "mer*eller*mindre_func" ].

mer*og*mer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mer*og*mer_prd ] !>,
    FLAGS.TRIGGER "mer*og*mer_func" ].

mer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mer_prd ] !>,
    FLAGS.TRIGGER "mer_func" ].

mere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mere_prd ] !>,
    FLAGS.TRIGGER "mere_func" ].

merkbart-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED merkbart_prd ] !>,
    FLAGS.TRIGGER "merkbart_func" ].

merkelig*nok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED merkelig*nok_prd ] !>,
    FLAGS.TRIGGER "merkelig*nok_func" ].

merkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED merkelig_prd ] !>,
    FLAGS.TRIGGER "merkelig_func" ].

mest*av*alt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mest*av*alt_prd ] !>,
    FLAGS.TRIGGER "mest*av*alt_func" ].

mest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mest_prd ] !>,
    FLAGS.TRIGGER "mest_func" ].

metervis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED metervis_prd ] !>,
    FLAGS.TRIGGER "metervis_func" ].

mezzoforte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mezzoforte_prd ] !>,
    FLAGS.TRIGGER "mezzoforte_func" ].

middels-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED middels_prd ] !>,
    FLAGS.TRIGGER "middels_func" ].

midsommers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midsommers_prd ] !>,
    FLAGS.TRIGGER "midsommers_func" ].

midt*på*lyse*dagen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midt*på*lyse*dagen_prd ] !>,
    FLAGS.TRIGGER "midt*på*lyse*dagen_func" ].

midt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midt_prd ] !>,
    FLAGS.TRIGGER "midt_func" ].

midtfjords-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtfjords_prd ] !>,
    FLAGS.TRIGGER "midtfjords_func" ].

midtskips-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtskips_prd ] !>,
    FLAGS.TRIGGER "midtskips_func" ].

midtsommers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtsommers_prd ] !>,
    FLAGS.TRIGGER "midtsommers_func" ].

midtveges-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtveges_prd ] !>,
    FLAGS.TRIGGER "midtveges_func" ].

midtvegs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtvegs_prd ] !>,
    FLAGS.TRIGGER "midtvegs_func" ].

midtveis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtveis_prd ] !>,
    FLAGS.TRIGGER "midtveis_func" ].

midtvinters-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midtvinters_prd ] !>,
    FLAGS.TRIGGER "midtvinters_func" ].

midvinters-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED midvinters_prd ] !>,
    FLAGS.TRIGGER "midvinters_func" ].

mildest*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mildest*talt_prd ] !>,
    FLAGS.TRIGGER "mildest*talt_func" ].

mildt*sagt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mildt*sagt_prd ] !>,
    FLAGS.TRIGGER "mildt*sagt_func" ].

mildt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mildt_prd ] !>,
    FLAGS.TRIGGER "mildt_func" ].

milevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED milevis_prd ] !>,
    FLAGS.TRIGGER "milevis_func" ].

millionvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED millionvis_prd ] !>,
    FLAGS.TRIGGER "millionvis_func" ].

mindre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mindre_prd ] !>,
    FLAGS.TRIGGER "mindre_func" ].

minimum-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED minimum_prd ] !>,
    FLAGS.TRIGGER "minimum_func" ].

minst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED minst_prd ] !>,
    FLAGS.TRIGGER "minst_func" ].

minstemann-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED minstemann_prd ] !>,
    FLAGS.TRIGGER "minstemann_func" ].

minus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED minus_prd ] !>,
    FLAGS.TRIGGER "minus_func" ].

miss-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED miss_prd ] !>,
    FLAGS.TRIGGER "miss_func" ].

mistenkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mistenkelig_prd ] !>,
    FLAGS.TRIGGER "mistenkelig_func" ].

mo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mo_prd ] !>,
    FLAGS.TRIGGER "mo_func" ].

moderat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED moderat_prd ] !>,
    FLAGS.TRIGGER "moderat_func" ].

molto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED molto_prd ] !>,
    FLAGS.TRIGGER "molto_func" ].

mor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mor_prd ] !>,
    FLAGS.TRIGGER "mor_func" ].

morgen*og*kveld-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED morgen*og*kveld_prd ] !>,
    FLAGS.TRIGGER "morgen*og*kveld_func" ].

mot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mot_prd ] !>,
    FLAGS.TRIGGER "mot_func" ].

motsols-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED motsols_prd ] !>,
    FLAGS.TRIGGER "motsols_func" ].

motstrøms-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED motstrøms_prd ] !>,
    FLAGS.TRIGGER "motstrøms_func" ].

mrperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mrperiod_prd ] !>,
    FLAGS.TRIGGER "mrperiod_func" ].

mrsperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mrsperiod_prd ] !>,
    FLAGS.TRIGGER "mrsperiod_func" ].

ms-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ms_prd ] !>,
    FLAGS.TRIGGER "ms_func" ].

mukk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mukk_prd ] !>,
    FLAGS.TRIGGER "mukk_func" ].

mukkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mukkende_prd ] !>,
    FLAGS.TRIGGER "mukkende_func" ].

muligens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED muligens_prd ] !>,
    FLAGS.TRIGGER "muligens_func" ].

muligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED muligvis_prd ] !>,
    FLAGS.TRIGGER "muligvis_func" ].

mullah-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mullah_prd ] !>,
    FLAGS.TRIGGER "mullah_func" ].

murende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED murende_prd ] !>,
    FLAGS.TRIGGER "murende_func" ].

murrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED murrende_prd ] !>,
    FLAGS.TRIGGER "murrende_func" ].

musende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED musende_prd ] !>,
    FLAGS.TRIGGER "musende_func" ].

mutters-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mutters_prd ] !>,
    FLAGS.TRIGGER "mutters_func" ].

mye-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED mye_prd ] !>,
    FLAGS.TRIGGER "mye_func" ].

månedsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED månedsvis_prd ] !>,
    FLAGS.TRIGGER "månedsvis_func" ].

møkk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED møkk_prd ] !>,
    FLAGS.TRIGGER "møkk_func" ].

n*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED n*for_prd ] !>,
    FLAGS.TRIGGER "n*for_func" ].

n*i-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED n*i_prd ] !>,
    FLAGS.TRIGGER "n*i_func" ].

n*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED n*om_prd ] !>,
    FLAGS.TRIGGER "n*om_func" ].

naggende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED naggende_prd ] !>,
    FLAGS.TRIGGER "naggende_func" ].

nasegrus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nasegrus_prd ] !>,
    FLAGS.TRIGGER "nasegrus_func" ].

nasjonalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nasjonalt_prd ] !>,
    FLAGS.TRIGGER "nasjonalt_func" ].

natt*og*dag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED natt*og*dag_prd ] !>,
    FLAGS.TRIGGER "natt*og*dag_func" ].

nattestid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nattestid_prd ] !>,
    FLAGS.TRIGGER "nattestid_func" ].

naturlig*nok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED naturlig*nok_prd ] !>,
    FLAGS.TRIGGER "naturlig*nok_func" ].

naturlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED naturlig_prd ] !>,
    FLAGS.TRIGGER "naturlig_func" ].

naturligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED naturligvis_prd ] !>,
    FLAGS.TRIGGER "naturligvis_func" ].

nauende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nauende_prd ] !>,
    FLAGS.TRIGGER "nauende_func" ].

navnlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED navnlig_prd ] !>,
    FLAGS.TRIGGER "navnlig_func" ].

ned-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ned_prd ] !>,
    FLAGS.TRIGGER "ned_func" ].

nedad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedad_prd ] !>,
    FLAGS.TRIGGER "nedad_func" ].

nedatil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedatil_prd ] !>,
    FLAGS.TRIGGER "nedatil_func" ].

nede*fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nede*fra_prd ] !>,
    FLAGS.TRIGGER "nede*fra_func" ].

nede-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nede_prd ] !>,
    FLAGS.TRIGGER "nede_func" ].

nedefra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedefra_prd ] !>,
    FLAGS.TRIGGER "nedefra_func" ].

nedenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedenfor_prd ] !>,
    FLAGS.TRIGGER "nedenfor_func" ].

nedenfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedenfra_prd ] !>,
    FLAGS.TRIGGER "nedenfra_func" ].

nedentil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedentil_prd ] !>,
    FLAGS.TRIGGER "nedentil_func" ].

nedenunder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedenunder_prd ] !>,
    FLAGS.TRIGGER "nedenunder_func" ].

nederst*nede-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nederst*nede_prd ] !>,
    FLAGS.TRIGGER "nederst*nede_func" ].

nederst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nederst_prd ] !>,
    FLAGS.TRIGGER "nederst_func" ].

nedi-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedi_prd ] !>,
    FLAGS.TRIGGER "nedi_func" ].

nedover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedover_prd ] !>,
    FLAGS.TRIGGER "nedover_func" ].

nedstrøms-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nedstrøms_prd ] !>,
    FLAGS.TRIGGER "nedstrøms_func" ].

nei-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nei_prd ] !>,
    FLAGS.TRIGGER "nei_func" ].

neigu-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED neigu_prd ] !>,
    FLAGS.TRIGGER "neigu_func" ].

neimen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED neimen_prd ] !>,
    FLAGS.TRIGGER "neimen_func" ].

nemlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nemlig_prd ] !>,
    FLAGS.TRIGGER "nemlig_func" ].

neppe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED neppe_prd ] !>,
    FLAGS.TRIGGER "neppe_func" ].

ner-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ner_prd ] !>,
    FLAGS.TRIGGER "ner_func" ].

nere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nere_prd ] !>,
    FLAGS.TRIGGER "nere_func" ].

nesegrus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nesegrus_prd ] !>,
    FLAGS.TRIGGER "nesegrus_func" ].

nest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nest_prd ] !>,
    FLAGS.TRIGGER "nest_func" ].

nesten-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nesten_prd ] !>,
    FLAGS.TRIGGER "nesten_func" ].

nestleder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nestleder_prd ] !>,
    FLAGS.TRIGGER "nestleder_func" ].

netto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED netto_prd ] !>,
    FLAGS.TRIGGER "netto_func" ].

nettopp-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nettopp_prd ] !>,
    FLAGS.TRIGGER "nettopp_func" ].

noe*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noe*av_prd ] !>,
    FLAGS.TRIGGER "noe*av_func" ].

noe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noe_prd ] !>,
    FLAGS.TRIGGER "noe_func" ].

noen*sinne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noen*sinne_prd ] !>,
    FLAGS.TRIGGER "noen*sinne_func" ].

noenlunde-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noenlunde_prd ] !>,
    FLAGS.TRIGGER "noenlunde_func" ].

noensinne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noensinne_prd ] !>,
    FLAGS.TRIGGER "noensinne_func" ].

noensteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noensteds_prd ] !>,
    FLAGS.TRIGGER "noensteds_func" ].

nok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nok_prd ] !>,
    FLAGS.TRIGGER "nok_func" ].

noksom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED noksom_prd ] !>,
    FLAGS.TRIGGER "noksom_func" ].

nokså-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nokså_prd ] !>,
    FLAGS.TRIGGER "nokså_func" ].

nonstop-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nonstop_prd ] !>,
    FLAGS.TRIGGER "nonstop_func" ].

nord*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nord*for_prd ] !>,
    FLAGS.TRIGGER "nord*for_func" ].

nord*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nord*om_prd ] !>,
    FLAGS.TRIGGER "nord*om_func" ].

nord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nord_prd ] !>,
    FLAGS.TRIGGER "nord_func" ].

nord-nordøstover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nord-nordøstover_prd ] !>,
    FLAGS.TRIGGER "nord-nordøstover_func" ].

nord-østover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nord-østover_prd ] !>,
    FLAGS.TRIGGER "nord-østover_func" ].

nordafjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordafjells_prd ] !>,
    FLAGS.TRIGGER "nordafjells_func" ].

nordaust-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordaust_prd ] !>,
    FLAGS.TRIGGER "nordaust_func" ].

nordenfjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordenfjells_prd ] !>,
    FLAGS.TRIGGER "nordenfjells_func" ].

nordenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordenfor_prd ] !>,
    FLAGS.TRIGGER "nordenfor_func" ].

nordfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordfra_prd ] !>,
    FLAGS.TRIGGER "nordfra_func" ].

nordost-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordost_prd ] !>,
    FLAGS.TRIGGER "nordost_func" ].

nordover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordover_prd ] !>,
    FLAGS.TRIGGER "nordover_func" ].

nordpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordpå_prd ] !>,
    FLAGS.TRIGGER "nordpå_func" ].

nordvest*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordvest*for_prd ] !>,
    FLAGS.TRIGGER "nordvest*for_func" ].

nordvest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordvest_prd ] !>,
    FLAGS.TRIGGER "nordvest_func" ].

nordvestover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordvestover_prd ] !>,
    FLAGS.TRIGGER "nordvestover_func" ].

nordøst*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordøst*for_prd ] !>,
    FLAGS.TRIGGER "nordøst*for_func" ].

nordøst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordøst_prd ] !>,
    FLAGS.TRIGGER "nordøst_func" ].

nordøstover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nordøstover_prd ] !>,
    FLAGS.TRIGGER "nordøstover_func" ].

normalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED normalt_prd ] !>,
    FLAGS.TRIGGER "normalt_func" ].

notabene-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED notabene_prd ] !>,
    FLAGS.TRIGGER "notabene_func" ].

nrperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nrperiod_prd ] !>,
    FLAGS.TRIGGER "nrperiod_func" ].

ntnu-stipendiat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ntnu-stipendiat_prd ] !>,
    FLAGS.TRIGGER "ntnu-stipendiat_func" ].

nu-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nu_prd ] !>,
    FLAGS.TRIGGER "nu_func" ].

nummer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nummer_prd ] !>,
    FLAGS.TRIGGER "nummer_func" ].

nv*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nv*for_prd ] !>,
    FLAGS.TRIGGER "nv*for_func" ].

nylig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nylig_prd ] !>,
    FLAGS.TRIGGER "nylig_func" ].

nyss-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nyss_prd ] !>,
    FLAGS.TRIGGER "nyss_func" ].

nØ*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nØ*for_prd ] !>,
    FLAGS.TRIGGER "nØ*for_func" ].

nå*nettopp-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nå*nettopp_prd ] !>,
    FLAGS.TRIGGER "nå*nettopp_func" ].

nå*og*da-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nå*og*da_prd ] !>,
    FLAGS.TRIGGER "nå*og*da_func" ].

nå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nå_prd ] !>,
    FLAGS.TRIGGER "nå_func" ].

nådeløst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nådeløst_prd ] !>,
    FLAGS.TRIGGER "nådeløst_func" ].

når*som*helst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED når*som*helst_prd ] !>,
    FLAGS.TRIGGER "når*som*helst_func" ].

når-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED når_prd ] !>,
    FLAGS.TRIGGER "når_func" ].

nåvel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nåvel_prd ] !>,
    FLAGS.TRIGGER "nåvel_func" ].

nær-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nær_prd ] !>,
    FLAGS.TRIGGER "nær_func" ].

nære-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nære_prd ] !>,
    FLAGS.TRIGGER "nære_func" ].

nærere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nærere_prd ] !>,
    FLAGS.TRIGGER "nærere_func" ].

nærest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nærest_prd ] !>,
    FLAGS.TRIGGER "nærest_func" ].

nærme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nærme_prd ] !>,
    FLAGS.TRIGGER "nærme_func" ].

nærmere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nærmere_prd ] !>,
    FLAGS.TRIGGER "nærmere_func" ].

nærmest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nærmest_prd ] !>,
    FLAGS.TRIGGER "nærmest_func" ].

nært-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nært_prd ] !>,
    FLAGS.TRIGGER "nært_func" ].

nødig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nødig_prd ] !>,
    FLAGS.TRIGGER "nødig_func" ].

nødvendigvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nødvendigvis_prd ] !>,
    FLAGS.TRIGGER "nødvendigvis_func" ].

nøyaktig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED nøyaktig_prd ] !>,
    FLAGS.TRIGGER "nøyaktig_func" ].

offside-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED offside_prd ] !>,
    FLAGS.TRIGGER "offside_func" ].

ofte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ofte_prd ] !>,
    FLAGS.TRIGGER "ofte_func" ].

oftere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oftere_prd ] !>,
    FLAGS.TRIGGER "oftere_func" ].

oftest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oftest_prd ] !>,
    FLAGS.TRIGGER "oftest_func" ].

og*sånn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED og*sånn_prd ] !>,
    FLAGS.TRIGGER "og*sånn_func" ].

også-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED også_prd ] !>,
    FLAGS.TRIGGER "også_func" ].

om*bord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*bord_prd ] !>,
    FLAGS.TRIGGER "om*bord_func" ].

om*igjen*og*om*igjen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*igjen*og*om*igjen_prd ] !>,
    FLAGS.TRIGGER "om*igjen*og*om*igjen_func" ].

om*igjen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*igjen_prd ] !>,
    FLAGS.TRIGGER "om*igjen_func" ].

om*lag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*lag_prd ] !>,
    FLAGS.TRIGGER "om*lag_func" ].

om*mulig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*mulig_prd ] !>,
    FLAGS.TRIGGER "om*mulig_func" ].

om*nødvendig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*nødvendig_prd ] !>,
    FLAGS.TRIGGER "om*nødvendig_func" ].

om*og*om*igjen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om*og*om*igjen_prd ] !>,
    FLAGS.TRIGGER "om*og*om*igjen_func" ].

om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED om_prd ] !>,
    FLAGS.TRIGGER "om_func" ].

ombord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ombord_prd ] !>,
    FLAGS.TRIGGER "ombord_func" ].

omkring-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED omkring_prd ] !>,
    FLAGS.TRIGGER "omkring_func" ].

omme-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED omme_prd ] !>,
    FLAGS.TRIGGER "omme_func" ].

omsider-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED omsider_prd ] !>,
    FLAGS.TRIGGER "omsider_func" ].

omsonst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED omsonst_prd ] !>,
    FLAGS.TRIGGER "omsonst_func" ].

omtrent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED omtrent_prd ] !>,
    FLAGS.TRIGGER "omtrent_func" ].

onkel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED onkel_prd ] !>,
    FLAGS.TRIGGER "onkel_func" ].

onnimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED onnimellom_prd ] !>,
    FLAGS.TRIGGER "onnimellom_func" ].

operasjonsleder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED operasjonsleder_prd ] !>,
    FLAGS.TRIGGER "operasjonsleder_func" ].

operiod*hperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED operiod*hperiod_prd ] !>,
    FLAGS.TRIGGER "operiod*hperiod_func" ].

operiodhperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED operiodhperiod_prd ] !>,
    FLAGS.TRIGGER "operiodhperiod_func" ].

opp*til-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED opp*til_prd ] !>,
    FLAGS.TRIGGER "opp*til_func" ].

opp-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED opp_prd ] !>,
    FLAGS.TRIGGER "opp_func" ].

oppad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppad_prd ] !>,
    FLAGS.TRIGGER "oppad_func" ].

oppe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppe_prd ] !>,
    FLAGS.TRIGGER "oppe_func" ].

oppetter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppetter_prd ] !>,
    FLAGS.TRIGGER "oppetter_func" ].

oppi-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppi_prd ] !>,
    FLAGS.TRIGGER "oppi_func" ].

oppimot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppimot_prd ] !>,
    FLAGS.TRIGGER "oppimot_func" ].

opplagt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED opplagt_prd ] !>,
    FLAGS.TRIGGER "opplagt_func" ].

oppom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppom_prd ] !>,
    FLAGS.TRIGGER "oppom_func" ].

opposisjonsleder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED opposisjonsleder_prd ] !>,
    FLAGS.TRIGGER "opposisjonsleder_func" ].

oppover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppover_prd ] !>,
    FLAGS.TRIGGER "oppover_func" ].

oppriktig*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppriktig*talt_prd ] !>,
    FLAGS.TRIGGER "oppriktig*talt_func" ].

oppriktig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppriktig_prd ] !>,
    FLAGS.TRIGGER "oppriktig_func" ].

opprinnelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED opprinnelig_prd ] !>,
    FLAGS.TRIGGER "opprinnelig_func" ].

oppsiktsvekkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppsiktsvekkende_prd ] !>,
    FLAGS.TRIGGER "oppsiktsvekkende_func" ].

oppstrøms-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppstrøms_prd ] !>,
    FLAGS.TRIGGER "oppstrøms_func" ].

opptil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED opptil_prd ] !>,
    FLAGS.TRIGGER "opptil_func" ].

oppunder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppunder_prd ] !>,
    FLAGS.TRIGGER "oppunder_func" ].

oppå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oppå_prd ] !>,
    FLAGS.TRIGGER "oppå_func" ].

ordentlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ordentlig_prd ] !>,
    FLAGS.TRIGGER "ordentlig_func" ].

ornitolog-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ornitolog_prd ] !>,
    FLAGS.TRIGGER "ornitolog_func" ].

oslo-biskop-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oslo-biskop_prd ] !>,
    FLAGS.TRIGGER "oslo-biskop_func" ].

ost-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ost_prd ] !>,
    FLAGS.TRIGGER "ost_func" ].

ovabords-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ovabords_prd ] !>,
    FLAGS.TRIGGER "ovabords_func" ].

ovatil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ovatil_prd ] !>,
    FLAGS.TRIGGER "ovatil_func" ].

oven-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oven_prd ] !>,
    FLAGS.TRIGGER "oven_func" ].

ovenbords-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ovenbords_prd ] !>,
    FLAGS.TRIGGER "ovenbords_func" ].

ovenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ovenfor_prd ] !>,
    FLAGS.TRIGGER "ovenfor_func" ].

ovenfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ovenfra_prd ] !>,
    FLAGS.TRIGGER "ovenfra_func" ].

ovenpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ovenpå_prd ] !>,
    FLAGS.TRIGGER "ovenpå_func" ].

oventil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED oventil_prd ] !>,
    FLAGS.TRIGGER "oventil_func" ].

over*alt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED over*alt_prd ] !>,
    FLAGS.TRIGGER "over*alt_func" ].

over*bord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED over*bord_prd ] !>,
    FLAGS.TRIGGER "over*bord_func" ].

over*ende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED over*ende_prd ] !>,
    FLAGS.TRIGGER "over*ende_func" ].

over-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED over_prd ] !>,
    FLAGS.TRIGGER "over_func" ].

overalt*ellers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overalt*ellers_prd ] !>,
    FLAGS.TRIGGER "overalt*ellers_func" ].

overalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overalt_prd ] !>,
    FLAGS.TRIGGER "overalt_func" ].

overbord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overbord_prd ] !>,
    FLAGS.TRIGGER "overbord_func" ].

overdrevent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overdrevent_prd ] !>,
    FLAGS.TRIGGER "overdrevent_func" ].

overdrevet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overdrevet_prd ] !>,
    FLAGS.TRIGGER "overdrevet_func" ].

overende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overende_prd ] !>,
    FLAGS.TRIGGER "overende_func" ].

overens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overens_prd ] !>,
    FLAGS.TRIGGER "overens_func" ].

overfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overfor_prd ] !>,
    FLAGS.TRIGGER "overfor_func" ].

overhodet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overhodet_prd ] !>,
    FLAGS.TRIGGER "overhodet_func" ].

overlag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overlag_prd ] !>,
    FLAGS.TRIGGER "overlag_func" ].

overmåte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overmåte_prd ] !>,
    FLAGS.TRIGGER "overmåte_func" ].

overordentlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overordentlig_prd ] !>,
    FLAGS.TRIGGER "overordentlig_func" ].

overraskende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overraskende_prd ] !>,
    FLAGS.TRIGGER "overraskende_func" ].

overskrevs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overskrevs_prd ] !>,
    FLAGS.TRIGGER "overskrevs_func" ].

overstrømmende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overstrømmende_prd ] !>,
    FLAGS.TRIGGER "overstrømmende_func" ].

overveiende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overveiende_prd ] !>,
    FLAGS.TRIGGER "overveiende_func" ].

overveldende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overveldende_prd ] !>,
    FLAGS.TRIGGER "overveldende_func" ].

overvettes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED overvettes_prd ] !>,
    FLAGS.TRIGGER "overvettes_func" ].

pakkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pakkende_prd ] !>,
    FLAGS.TRIGGER "pakkende_func" ].

pal-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pal_prd ] !>,
    FLAGS.TRIGGER "pal_func" ].

pappa-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pappa_prd ] !>,
    FLAGS.TRIGGER "pappa_func" ].

paradoksalt*nok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED paradoksalt*nok_prd ] !>,
    FLAGS.TRIGGER "paradoksalt*nok_func" ].

parlando-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED parlando_prd ] !>,
    FLAGS.TRIGGER "parlando_func" ].

partileder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED partileder_prd ] !>,
    FLAGS.TRIGGER "partileder_func" ].

partout-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED partout_prd ] !>,
    FLAGS.TRIGGER "partout_func" ].

parvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED parvis_prd ] !>,
    FLAGS.TRIGGER "parvis_func" ].

passe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED passe_prd ] !>,
    FLAGS.TRIGGER "passe_func" ].

per*definisjon-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED per*definisjon_prd ] !>,
    FLAGS.TRIGGER "per*definisjon_func" ].

per-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED per_prd ] !>,
    FLAGS.TRIGGER "per_func" ].

perfekt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED perfekt_prd ] !>,
    FLAGS.TRIGGER "perfekt_func" ].

permanent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED permanent_prd ] !>,
    FLAGS.TRIGGER "permanent_func" ].

pgaperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pgaperiod_prd ] !>,
    FLAGS.TRIGGER "pgaperiod_func" ].

pianissimo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pianissimo_prd ] !>,
    FLAGS.TRIGGER "pianissimo_func" ].

piano-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED piano_prd ] !>,
    FLAGS.TRIGGER "piano_func" ].

pill-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pill_prd ] !>,
    FLAGS.TRIGGER "pill_func" ].

pine-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pine_prd ] !>,
    FLAGS.TRIGGER "pine_func" ].

pinende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pinende_prd ] !>,
    FLAGS.TRIGGER "pinende_func" ].

pinnende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pinnende_prd ] !>,
    FLAGS.TRIGGER "pinnende_func" ].

piskende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED piskende_prd ] !>,
    FLAGS.TRIGGER "piskende_func" ].

pist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pist_prd ] !>,
    FLAGS.TRIGGER "pist_func" ].

pizzicato-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pizzicato_prd ] !>,
    FLAGS.TRIGGER "pizzicato_func" ].

pladask-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pladask_prd ] !>,
    FLAGS.TRIGGER "pladask_func" ].

plagsomt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED plagsomt_prd ] !>,
    FLAGS.TRIGGER "plagsomt_func" ].

plent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED plent_prd ] !>,
    FLAGS.TRIGGER "plent_func" ].

plenty-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED plenty_prd ] !>,
    FLAGS.TRIGGER "plenty_func" ].

pluss-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pluss_prd ] !>,
    FLAGS.TRIGGER "pluss_func" ].

plutselig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED plutselig_prd ] !>,
    FLAGS.TRIGGER "plutselig_func" ].

pokkers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pokkers_prd ] !>,
    FLAGS.TRIGGER "pokkers_func" ].

politisk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED politisk_prd ] !>,
    FLAGS.TRIGGER "politisk_func" ].

porsjonsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED porsjonsvis_prd ] !>,
    FLAGS.TRIGGER "porsjonsvis_func" ].

portamento-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED portamento_prd ] !>,
    FLAGS.TRIGGER "portamento_func" ].

portato-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED portato_prd ] !>,
    FLAGS.TRIGGER "portato_func" ].

positivt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED positivt_prd ] !>,
    FLAGS.TRIGGER "positivt_func" ].

potensielt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED potensielt_prd ] !>,
    FLAGS.TRIGGER "potensielt_func" ].

praktisk*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED praktisk*talt_prd ] !>,
    FLAGS.TRIGGER "praktisk*talt_func" ].

prestissimo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prestissimo_prd ] !>,
    FLAGS.TRIGGER "prestissimo_func" ].

presto-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED presto_prd ] !>,
    FLAGS.TRIGGER "presto_func" ].

prikk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prikk_prd ] !>,
    FLAGS.TRIGGER "prikk_func" ].

primo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED primo_prd ] !>,
    FLAGS.TRIGGER "primo_func" ].

prinsipielt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prinsipielt_prd ] !>,
    FLAGS.TRIGGER "prinsipielt_func" ].

proforma-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED proforma_prd ] !>,
    FLAGS.TRIGGER "proforma_func" ].

prompt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prompt_prd ] !>,
    FLAGS.TRIGGER "prompt_func" ].

prompte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prompte_prd ] !>,
    FLAGS.TRIGGER "prompte_func" ].

propp-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED propp_prd ] !>,
    FLAGS.TRIGGER "propp_func" ].

proppende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED proppende_prd ] !>,
    FLAGS.TRIGGER "proppende_func" ].

prosentvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prosentvis_prd ] !>,
    FLAGS.TRIGGER "prosentvis_func" ].

prperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED prperiod_prd ] !>,
    FLAGS.TRIGGER "prperiod_func" ].

pst-sjef-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pst-sjef_prd ] !>,
    FLAGS.TRIGGER "pst-sjef_func" ].

psykologisk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED psykologisk_prd ] !>,
    FLAGS.TRIGGER "psykologisk_func" ].

pukka-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pukka_prd ] !>,
    FLAGS.TRIGGER "pukka_func" ].

puljevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED puljevis_prd ] !>,
    FLAGS.TRIGGER "puljevis_func" ].

punktvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED punktvis_prd ] !>,
    FLAGS.TRIGGER "punktvis_func" ].

pyton-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pyton_prd ] !>,
    FLAGS.TRIGGER "pyton_func" ].

på*alvor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*alvor_prd ] !>,
    FLAGS.TRIGGER "på*alvor_func" ].

på*avveie-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*avveie_prd ] !>,
    FLAGS.TRIGGER "på*avveie_func" ].

på*det*rene-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*det*rene_prd ] !>,
    FLAGS.TRIGGER "på*det*rene_func" ].

på*en*eller*annen*måte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*en*eller*annen*måte_prd ] !>,
    FLAGS.TRIGGER "på*en*eller*annen*måte_func" ].

på*en*måte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*en*måte_prd ] !>,
    FLAGS.TRIGGER "på*en*måte_func" ].

på*ferde-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*ferde_prd ] !>,
    FLAGS.TRIGGER "på*ferde_func" ].

på*forhånd-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*forhånd_prd ] !>,
    FLAGS.TRIGGER "på*forhånd_func" ].

på*grunn*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*grunn*av_prd ] !>,
    FLAGS.TRIGGER "på*grunn*av_func" ].

på*hengende*håret-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*hengende*håret_prd ] !>,
    FLAGS.TRIGGER "på*hengende*håret_func" ].

på*hodet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*hodet_prd ] !>,
    FLAGS.TRIGGER "på*hodet_func" ].

på*kryss*og*tvers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*kryss*og*tvers_prd ] !>,
    FLAGS.TRIGGER "på*kryss*og*tvers_func" ].

på*langs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*langs_prd ] !>,
    FLAGS.TRIGGER "på*langs_func" ].

på*lenge-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*lenge_prd ] !>,
    FLAGS.TRIGGER "på*lenge_func" ].

på*ny-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*ny_prd ] !>,
    FLAGS.TRIGGER "på*ny_func" ].

på*nytt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*nytt_prd ] !>,
    FLAGS.TRIGGER "på*nytt_func" ].

på*sin*side-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*sin*side_prd ] !>,
    FLAGS.TRIGGER "på*sin*side_func" ].

på*skrå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*skrå_prd ] !>,
    FLAGS.TRIGGER "på*skrå_func" ].

på*tross*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*tross*av_prd ] !>,
    FLAGS.TRIGGER "på*tross*av_func" ].

på*tvers*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*tvers*av_prd ] !>,
    FLAGS.TRIGGER "på*tvers*av_func" ].

på*tvers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*tvers_prd ] !>,
    FLAGS.TRIGGER "på*tvers_func" ].

på*vegne*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på*vegne*av_prd ] !>,
    FLAGS.TRIGGER "på*vegne*av_func" ].

på-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED på_prd ] !>,
    FLAGS.TRIGGER "på_func" ].

påfallende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED påfallende_prd ] !>,
    FLAGS.TRIGGER "påfallende_func" ].

pånytt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pånytt_prd ] !>,
    FLAGS.TRIGGER "pånytt_func" ].

påtagelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED påtagelig_prd ] !>,
    FLAGS.TRIGGER "påtagelig_func" ].

påtakelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED påtakelig_prd ] !>,
    FLAGS.TRIGGER "påtakelig_func" ].

påtatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED påtatt_prd ] !>,
    FLAGS.TRIGGER "påtatt_func" ].

påtrengende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED påtrengende_prd ] !>,
    FLAGS.TRIGGER "påtrengende_func" ].

pære-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED pære_prd ] !>,
    FLAGS.TRIGGER "pære_func" ].

rammende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rammende_prd ] !>,
    FLAGS.TRIGGER "rammende_func" ].

rangsøles-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rangsøles_prd ] !>,
    FLAGS.TRIGGER "rangsøles_func" ].

rasende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rasende_prd ] !>,
    FLAGS.TRIGGER "rasende_func" ].

raskt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED raskt_prd ] !>,
    FLAGS.TRIGGER "raskt_func" ].

ratevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ratevis_prd ] !>,
    FLAGS.TRIGGER "ratevis_func" ].

ratt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ratt_prd ] !>,
    FLAGS.TRIGGER "ratt_func" ].

rav-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rav_prd ] !>,
    FLAGS.TRIGGER "rav_func" ].

ravende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ravende_prd ] !>,
    FLAGS.TRIGGER "ravende_func" ].

rede-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rede_prd ] !>,
    FLAGS.TRIGGER "rede_func" ].

refl5-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED refl5_prd ] !>,
    FLAGS.TRIGGER "refl5_func" ].

reint-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED reint_prd ] !>,
    FLAGS.TRIGGER "reint_func" ].

relativt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED relativt_prd ] !>,
    FLAGS.TRIGGER "relativt_func" ].

rent*ut*sagt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rent*ut*sagt_prd ] !>,
    FLAGS.TRIGGER "rent*ut*sagt_func" ].

rent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rent_prd ] !>,
    FLAGS.TRIGGER "rent_func" ].

respektive-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED respektive_prd ] !>,
    FLAGS.TRIGGER "respektive_func" ].

rett*og*slett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rett*og*slett_prd ] !>,
    FLAGS.TRIGGER "rett*og*slett_func" ].

rett*som*det*er-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rett*som*det*er_prd ] !>,
    FLAGS.TRIGGER "rett*som*det*er_func" ].

rett*som*det*var-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rett*som*det*var_prd ] !>,
    FLAGS.TRIGGER "rett*som*det*var_func" ].

rett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rett_prd ] !>,
    FLAGS.TRIGGER "rett_func" ].

rettsøles-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rettsøles_prd ] !>,
    FLAGS.TRIGGER "rettsøles_func" ].

reverenter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED reverenter_prd ] !>,
    FLAGS.TRIGGER "reverenter_func" ].

revnende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED revnende_prd ] !>,
    FLAGS.TRIGGER "revnende_func" ].

ridder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ridder_prd ] !>,
    FLAGS.TRIGGER "ridder_func" ].

riktig*nok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED riktig*nok_prd ] !>,
    FLAGS.TRIGGER "riktig*nok_func" ].

riktig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED riktig_prd ] !>,
    FLAGS.TRIGGER "riktig_func" ].

riktignok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED riktignok_prd ] !>,
    FLAGS.TRIGGER "riktignok_func" ].

rimelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rimelig_prd ] !>,
    FLAGS.TRIGGER "rimelig_func" ].

rimeligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rimeligvis_prd ] !>,
    FLAGS.TRIGGER "rimeligvis_func" ].

ringside-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ringside_prd ] !>,
    FLAGS.TRIGGER "ringside_func" ].

rispende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rispende_prd ] !>,
    FLAGS.TRIGGER "rispende_func" ].

ritardando-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ritardando_prd ] !>,
    FLAGS.TRIGGER "ritardando_func" ].

riv*ruskende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED riv*ruskende_prd ] !>,
    FLAGS.TRIGGER "riv*ruskende_func" ].

riv-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED riv_prd ] !>,
    FLAGS.TRIGGER "riv_func" ].

rubato-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rubato_prd ] !>,
    FLAGS.TRIGGER "rubato_func" ].

rundt*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rundt*om_prd ] !>,
    FLAGS.TRIGGER "rundt*om_func" ].

rundt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rundt_prd ] !>,
    FLAGS.TRIGGER "rundt_func" ].

ruskende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ruskende_prd ] !>,
    FLAGS.TRIGGER "ruskende_func" ].

rykende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rykende_prd ] !>,
    FLAGS.TRIGGER "rykende_func" ].

rykkevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rykkevis_prd ] !>,
    FLAGS.TRIGGER "rykkevis_func" ].

rørende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED rørende_prd ] !>,
    FLAGS.TRIGGER "rørende_func" ].

s*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED s*for_prd ] !>,
    FLAGS.TRIGGER "s*for_func" ].

s*i-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED s*i_prd ] !>,
    FLAGS.TRIGGER "s*i_func" ].

sabla-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sabla_prd ] !>,
    FLAGS.TRIGGER "sabla_func" ].

saktelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED saktelig_prd ] !>,
    FLAGS.TRIGGER "saktelig_func" ].

saktens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED saktens_prd ] !>,
    FLAGS.TRIGGER "saktens_func" ].

samlet*sett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED samlet*sett_prd ] !>,
    FLAGS.TRIGGER "samlet*sett_func" ].

sammen*med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sammen*med_prd ] !>,
    FLAGS.TRIGGER "sammen*med_func" ].

sammen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sammen_prd ] !>,
    FLAGS.TRIGGER "sammen_func" ].

sammen-med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sammen-med_prd ] !>,
    FLAGS.TRIGGER "sammen-med_func" ].

sammesteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sammesteds_prd ] !>,
    FLAGS.TRIGGER "sammesteds_func" ].

sammestedsfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sammestedsfra_prd ] !>,
    FLAGS.TRIGGER "sammestedsfra_func" ].

samstundes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED samstundes_prd ] !>,
    FLAGS.TRIGGER "samstundes_func" ].

samt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED samt_prd ] !>,
    FLAGS.TRIGGER "samt_func" ].

samtidig*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED samtidig*som_prd ] !>,
    FLAGS.TRIGGER "samtidig*som_func" ].

sann-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sann_prd ] !>,
    FLAGS.TRIGGER "sann_func" ].

sannelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sannelig_prd ] !>,
    FLAGS.TRIGGER "sannelig_func" ].

sannsynligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sannsynligvis_prd ] !>,
    FLAGS.TRIGGER "sannsynligvis_func" ].

sant*for*dyden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sant*for*dyden_prd ] !>,
    FLAGS.TRIGGER "sant*for*dyden_func" ].

sant*å*si-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sant*å*si_prd ] !>,
    FLAGS.TRIGGER "sant*å*si_func" ].

scilicet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED scilicet_prd ] !>,
    FLAGS.TRIGGER "scilicet_func" ].

seg*imellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED seg*imellom_prd ] !>,
    FLAGS.TRIGGER "seg*imellom_func" ].

seinhaustes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED seinhaustes_prd ] !>,
    FLAGS.TRIGGER "seinhaustes_func" ].

seinhøstes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED seinhøstes_prd ] !>,
    FLAGS.TRIGGER "seinhøstes_func" ].

selv*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED selv*om_prd ] !>,
    FLAGS.TRIGGER "selv*om_func" ].

selv-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED selv_prd ] !>,
    FLAGS.TRIGGER "selv_func" ].

selveste-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED selveste_prd ] !>,
    FLAGS.TRIGGER "selveste_func" ].

selvfølgelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED selvfølgelig_prd ] !>,
    FLAGS.TRIGGER "selvfølgelig_func" ].

selvsagt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED selvsagt_prd ] !>,
    FLAGS.TRIGGER "selvsagt_func" ].

senhøstes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED senhøstes_prd ] !>,
    FLAGS.TRIGGER "senhøstes_func" ].

seriøst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED seriøst_prd ] !>,
    FLAGS.TRIGGER "seriøst_func" ].

sett*under*ett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sett*under*ett_prd ] !>,
    FLAGS.TRIGGER "sett*under*ett_func" ].

sia-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sia_prd ] !>,
    FLAGS.TRIGGER "sia_func" ].

sidelangs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sidelangs_prd ] !>,
    FLAGS.TRIGGER "sidelangs_func" ].

sidelengs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sidelengs_prd ] !>,
    FLAGS.TRIGGER "sidelengs_func" ].

siden*sist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED siden*sist_prd ] !>,
    FLAGS.TRIGGER "siden*sist_func" ].

siden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED siden_prd ] !>,
    FLAGS.TRIGGER "siden_func" ].

sideveges-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sideveges_prd ] !>,
    FLAGS.TRIGGER "sideveges_func" ].

sidevegs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sidevegs_prd ] !>,
    FLAGS.TRIGGER "sidevegs_func" ].

sideveis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sideveis_prd ] !>,
    FLAGS.TRIGGER "sideveis_func" ].

signifikant-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED signifikant_prd ] !>,
    FLAGS.TRIGGER "signifikant_func" ].

sikkerlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sikkerlig_prd ] !>,
    FLAGS.TRIGGER "sikkerlig_func" ].

sikkert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sikkert_prd ] !>,
    FLAGS.TRIGGER "sikkert_func" ].

sikksakk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sikksakk_prd ] !>,
    FLAGS.TRIGGER "sikksakk_func" ].

silde-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED silde_prd ] !>,
    FLAGS.TRIGGER "silde_func" ].

simpelthen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED simpelthen_prd ] !>,
    FLAGS.TRIGGER "simpelthen_func" ].

sinnssvakt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sinnssvakt_prd ] !>,
    FLAGS.TRIGGER "sinnssvakt_func" ].

sinnssykt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sinnssykt_prd ] !>,
    FLAGS.TRIGGER "sinnssykt_func" ].

sir-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sir_prd ] !>,
    FLAGS.TRIGGER "sir_func" ].

sist*fredag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*fredag_prd ] !>,
    FLAGS.TRIGGER "sist*fredag_func" ].

sist*høst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*høst_prd ] !>,
    FLAGS.TRIGGER "sist*høst_func" ].

sist*lørdag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*lørdag_prd ] !>,
    FLAGS.TRIGGER "sist*lørdag_func" ].

sist*mandag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*mandag_prd ] !>,
    FLAGS.TRIGGER "sist*mandag_func" ].

sist*onsdag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*onsdag_prd ] !>,
    FLAGS.TRIGGER "sist*onsdag_func" ].

sist*sommer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*sommer_prd ] !>,
    FLAGS.TRIGGER "sist*sommer_func" ].

sist*søndag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*søndag_prd ] !>,
    FLAGS.TRIGGER "sist*søndag_func" ].

sist*tirsdag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*tirsdag_prd ] !>,
    FLAGS.TRIGGER "sist*tirsdag_func" ].

sist*torsdag-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*torsdag_prd ] !>,
    FLAGS.TRIGGER "sist*torsdag_func" ].

sist*vinter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*vinter_prd ] !>,
    FLAGS.TRIGGER "sist*vinter_func" ].

sist*vår-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist*vår_prd ] !>,
    FLAGS.TRIGGER "sist*vår_func" ].

sist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sist_prd ] !>,
    FLAGS.TRIGGER "sist_func" ].

sistpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sistpå_prd ] !>,
    FLAGS.TRIGGER "sistpå_func" ].

sjelden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjelden_prd ] !>,
    FLAGS.TRIGGER "sjelden_func" ].

sjeldent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjeldent_prd ] !>,
    FLAGS.TRIGGER "sjeldent_func" ].

sjokkerende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjokkerende_prd ] !>,
    FLAGS.TRIGGER "sjokkerende_func" ].

sjøl*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjøl*om_prd ] !>,
    FLAGS.TRIGGER "sjøl*om_func" ].

sjøl-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjøl_prd ] !>,
    FLAGS.TRIGGER "sjøl_func" ].

sjøleies-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjøleies_prd ] !>,
    FLAGS.TRIGGER "sjøleies_func" ].

sjøleis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjøleis_prd ] !>,
    FLAGS.TRIGGER "sjøleis_func" ].

sjølsagt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjølsagt_prd ] !>,
    FLAGS.TRIGGER "sjølsagt_func" ].

sjølveste-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjølveste_prd ] !>,
    FLAGS.TRIGGER "sjølveste_func" ].

sjøverts-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sjøverts_prd ] !>,
    FLAGS.TRIGGER "sjøverts_func" ].

skal*vi*si-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skal*vi*si_prd ] !>,
    FLAGS.TRIGGER "skal*vi*si_func" ].

skammelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skammelig_prd ] !>,
    FLAGS.TRIGGER "skammelig_func" ].

skarpt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skarpt_prd ] !>,
    FLAGS.TRIGGER "skarpt_func" ].

skauleies-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skauleies_prd ] !>,
    FLAGS.TRIGGER "skauleies_func" ].

skeis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skeis_prd ] !>,
    FLAGS.TRIGGER "skeis_func" ].

skiftevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skiftevis_prd ] !>,
    FLAGS.TRIGGER "skiftevis_func" ].

skikkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skikkelig_prd ] !>,
    FLAGS.TRIGGER "skikkelig_func" ].

skinnende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skinnende_prd ] !>,
    FLAGS.TRIGGER "skinnende_func" ].

skita-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skita_prd ] !>,
    FLAGS.TRIGGER "skita_func" ].

skjærende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skjærende_prd ] !>,
    FLAGS.TRIGGER "skjærende_func" ].

skjøns-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skjøns_prd ] !>,
    FLAGS.TRIGGER "skjøns_func" ].

skjønt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skjønt_prd ] !>,
    FLAGS.TRIGGER "skjønt_func" ].

skogleies-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skogleies_prd ] !>,
    FLAGS.TRIGGER "skogleies_func" ].

skokkevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skokkevis_prd ] !>,
    FLAGS.TRIGGER "skokkevis_func" ].

skrekkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skrekkelig_prd ] !>,
    FLAGS.TRIGGER "skrekkelig_func" ].

skremmende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skremmende_prd ] !>,
    FLAGS.TRIGGER "skremmende_func" ].

skrevs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skrevs_prd ] !>,
    FLAGS.TRIGGER "skrevs_func" ].

skrittvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skrittvis_prd ] !>,
    FLAGS.TRIGGER "skrittvis_func" ].

skrås-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skrås_prd ] !>,
    FLAGS.TRIGGER "skrås_func" ].

skuffende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skuffende_prd ] !>,
    FLAGS.TRIGGER "skuffende_func" ].

skulder*mot*skulder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skulder*mot*skulder_prd ] !>,
    FLAGS.TRIGGER "skulder*mot*skulder_func" ].

skyllende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skyllende_prd ] !>,
    FLAGS.TRIGGER "skyllende_func" ].

skåldende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED skåldende_prd ] !>,
    FLAGS.TRIGGER "skåldende_func" ].

slett*ikke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slett*ikke_prd ] !>,
    FLAGS.TRIGGER "slett*ikke_func" ].

slettes*ikke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slettes*ikke_prd ] !>,
    FLAGS.TRIGGER "slettes*ikke_func" ].

slettes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slettes_prd ] !>,
    FLAGS.TRIGGER "slettes_func" ].

slik*at-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slik*at_prd ] !>,
    FLAGS.TRIGGER "slik*at_func" ].

slik*sett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slik*sett_prd ] !>,
    FLAGS.TRIGGER "slik*sett_func" ].

slik*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slik*som_prd ] !>,
    FLAGS.TRIGGER "slik*som_func" ].

slik-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED slik_prd ] !>,
    FLAGS.TRIGGER "slik_func" ].

sluttelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sluttelig_prd ] !>,
    FLAGS.TRIGGER "sluttelig_func" ].

smekk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED smekk_prd ] !>,
    FLAGS.TRIGGER "smekk_func" ].

smellende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED smellende_prd ] !>,
    FLAGS.TRIGGER "smellende_func" ].

smertelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED smertelig_prd ] !>,
    FLAGS.TRIGGER "smertelig_func" ].

småningom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED småningom_prd ] !>,
    FLAGS.TRIGGER "småningom_func" ].

smått-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED smått_prd ] !>,
    FLAGS.TRIGGER "smått_func" ].

snart-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snart_prd ] !>,
    FLAGS.TRIGGER "snart_func" ].

sneisevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sneisevis_prd ] !>,
    FLAGS.TRIGGER "sneisevis_func" ].

snesevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snesevis_prd ] !>,
    FLAGS.TRIGGER "snesevis_func" ].

snuft-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snuft_prd ] !>,
    FLAGS.TRIGGER "snuft_func" ].

snupt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snupt_prd ] !>,
    FLAGS.TRIGGER "snupt_func" ].

snyt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snyt_prd ] !>,
    FLAGS.TRIGGER "snyt_func" ].

snyta-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snyta_prd ] !>,
    FLAGS.TRIGGER "snyta_func" ].

snyte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED snyte_prd ] !>,
    FLAGS.TRIGGER "snyte_func" ].

sogar-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sogar_prd ] !>,
    FLAGS.TRIGGER "sogar_func" ].

solo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED solo_prd ] !>,
    FLAGS.TRIGGER "solo_func" ].

som*alltid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*alltid_prd ] !>,
    FLAGS.TRIGGER "som*alltid_func" ].

som*følger-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*følger_prd ] !>,
    FLAGS.TRIGGER "som*følger_func" ].

som*før-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*før_prd ] !>,
    FLAGS.TRIGGER "som*før_func" ].

som*oftest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*oftest_prd ] !>,
    FLAGS.TRIGGER "som*oftest_func" ].

som*om-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*om_prd ] !>,
    FLAGS.TRIGGER "som*om_func" ].

som*regel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*regel_prd ] !>,
    FLAGS.TRIGGER "som*regel_func" ].

som*sagt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*sagt_prd ] !>,
    FLAGS.TRIGGER "som*sagt_func" ].

som*sådan-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*sådan_prd ] !>,
    FLAGS.TRIGGER "som*sådan_func" ].

som*vanlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*vanlig_prd ] !>,
    FLAGS.TRIGGER "som*vanlig_func" ].

som*ventet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som*ventet_prd ] !>,
    FLAGS.TRIGGER "som*ventet_func" ].

som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED som_prd ] !>,
    FLAGS.TRIGGER "som_func" ].

sommerstid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sommerstid_prd ] !>,
    FLAGS.TRIGGER "sommerstid_func" ].

sommesteds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sommesteds_prd ] !>,
    FLAGS.TRIGGER "sommesteds_func" ].

sosialt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sosialt_prd ] !>,
    FLAGS.TRIGGER "sosialt_func" ].

spenna-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spenna_prd ] !>,
    FLAGS.TRIGGER "spenna_func" ].

spennende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spennende_prd ] !>,
    FLAGS.TRIGGER "spennende_func" ].

spent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spent_prd ] !>,
    FLAGS.TRIGGER "spent_func" ].

speriod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED speriod_prd ] !>,
    FLAGS.TRIGGER "speriod_func" ].

spesielt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spesielt_prd ] !>,
    FLAGS.TRIGGER "spesielt_func" ].

spika-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spika_prd ] !>,
    FLAGS.TRIGGER "spika_func" ].

spikende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spikende_prd ] !>,
    FLAGS.TRIGGER "spikende_func" ].

spildrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spildrende_prd ] !>,
    FLAGS.TRIGGER "spildrende_func" ].

spill-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED spill_prd ] !>,
    FLAGS.TRIGGER "spill_func" ].

splinter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED splinter_prd ] !>,
    FLAGS.TRIGGER "splinter_func" ].

splitter-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED splitter_prd ] !>,
    FLAGS.TRIGGER "splitter_func" ].

sporenstreks-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sporenstreks_prd ] !>,
    FLAGS.TRIGGER "sporenstreks_func" ].

sprangvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sprangvis_prd ] !>,
    FLAGS.TRIGGER "sprangvis_func" ].

sprell-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sprell_prd ] !>,
    FLAGS.TRIGGER "sprell_func" ].

sprettende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sprettende_prd ] !>,
    FLAGS.TRIGGER "sprettende_func" ].

sprut-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sprut_prd ] !>,
    FLAGS.TRIGGER "sprut_func" ].

sprutende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sprutende_prd ] !>,
    FLAGS.TRIGGER "sprutende_func" ].

sprøyte-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sprøyte_prd ] !>,
    FLAGS.TRIGGER "sprøyte_func" ].

srengt*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED srengt*talt_prd ] !>,
    FLAGS.TRIGGER "srengt*talt_func" ].

stabilt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stabilt_prd ] !>,
    FLAGS.TRIGGER "stabilt_func" ].

stadig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stadig_prd ] !>,
    FLAGS.TRIGGER "stadig_func" ].

stadsfysikus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stadsfysikus_prd ] !>,
    FLAGS.TRIGGER "stadsfysikus_func" ].

stakkato-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stakkato_prd ] !>,
    FLAGS.TRIGGER "stakkato_func" ].

stapp-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stapp_prd ] !>,
    FLAGS.TRIGGER "stapp_func" ].

stappa-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stappa_prd ] !>,
    FLAGS.TRIGGER "stappa_func" ].

stappende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stappende_prd ] !>,
    FLAGS.TRIGGER "stappende_func" ].

staurende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED staurende_prd ] !>,
    FLAGS.TRIGGER "staurende_func" ].

stedvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stedvis_prd ] !>,
    FLAGS.TRIGGER "stedvis_func" ].

steika-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED steika_prd ] !>,
    FLAGS.TRIGGER "steika_func" ].

steike-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED steike_prd ] !>,
    FLAGS.TRIGGER "steike_func" ].

steikende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED steikende_prd ] !>,
    FLAGS.TRIGGER "steikende_func" ].

stein-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stein_prd ] !>,
    FLAGS.TRIGGER "stein_func" ].

steinsens-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED steinsens_prd ] !>,
    FLAGS.TRIGGER "steinsens_func" ].

stekende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stekende_prd ] !>,
    FLAGS.TRIGGER "stekende_func" ].

sterkt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sterkt_prd ] !>,
    FLAGS.TRIGGER "sterkt_func" ].

stetse-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stetse_prd ] !>,
    FLAGS.TRIGGER "stetse_func" ].

stikk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stikk_prd ] !>,
    FLAGS.TRIGGER "stikk_func" ].

stille-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stille_prd ] !>,
    FLAGS.TRIGGER "stille_func" ].

stokk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stokk_prd ] !>,
    FLAGS.TRIGGER "stokk_func" ].

stokkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stokkende_prd ] !>,
    FLAGS.TRIGGER "stokkende_func" ].

storlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED storlig_prd ] !>,
    FLAGS.TRIGGER "storlig_func" ].

stormende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stormende_prd ] !>,
    FLAGS.TRIGGER "stormende_func" ].

stort*sett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stort*sett_prd ] !>,
    FLAGS.TRIGGER "stort*sett_func" ].

stort-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stort_prd ] !>,
    FLAGS.TRIGGER "stort_func" ].

straks-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED straks_prd ] !>,
    FLAGS.TRIGGER "straks_func" ].

strengt*tatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED strengt*tatt_prd ] !>,
    FLAGS.TRIGGER "strengt*tatt_func" ].

strengt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED strengt_prd ] !>,
    FLAGS.TRIGGER "strengt_func" ].

stringendo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stringendo_prd ] !>,
    FLAGS.TRIGGER "stringendo_func" ].

strålende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED strålende_prd ] !>,
    FLAGS.TRIGGER "strålende_func" ].

stuende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stuende_prd ] !>,
    FLAGS.TRIGGER "stuende_func" ].

stummende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stummende_prd ] !>,
    FLAGS.TRIGGER "stummende_func" ].

stundimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stundimellom_prd ] !>,
    FLAGS.TRIGGER "stundimellom_func" ].

stundom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stundom_prd ] !>,
    FLAGS.TRIGGER "stundom_func" ].

stundomtil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stundomtil_prd ] !>,
    FLAGS.TRIGGER "stundomtil_func" ].

stup-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stup_prd ] !>,
    FLAGS.TRIGGER "stup_func" ].

stupende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stupende_prd ] !>,
    FLAGS.TRIGGER "stupende_func" ].

stuvende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stuvende_prd ] !>,
    FLAGS.TRIGGER "stuvende_func" ].

styggelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED styggelig_prd ] !>,
    FLAGS.TRIGGER "styggelig_func" ].

styggende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED styggende_prd ] !>,
    FLAGS.TRIGGER "styggende_func" ].

stykkevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stykkevis_prd ] !>,
    FLAGS.TRIGGER "stykkevis_func" ].

styrbord-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED styrbord_prd ] !>,
    FLAGS.TRIGGER "styrbord_func" ].

styreleder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED styreleder_prd ] !>,
    FLAGS.TRIGGER "styreleder_func" ].

stær-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED stær_prd ] !>,
    FLAGS.TRIGGER "stær_func" ].

støtt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED støtt_prd ] !>,
    FLAGS.TRIGGER "støtt_func" ].

støtvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED støtvis_prd ] !>,
    FLAGS.TRIGGER "støtvis_func" ].

støytvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED støytvis_prd ] !>,
    FLAGS.TRIGGER "støytvis_func" ].

sund-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sund_prd ] !>,
    FLAGS.TRIGGER "sund_func" ].

surr-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED surr_prd ] !>,
    FLAGS.TRIGGER "surr_func" ].

susende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED susende_prd ] !>,
    FLAGS.TRIGGER "susende_func" ].

suverent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED suverent_prd ] !>,
    FLAGS.TRIGGER "suverent_func" ].

sv*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sv*for_prd ] !>,
    FLAGS.TRIGGER "sv*for_func" ].

svakt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED svakt_prd ] !>,
    FLAGS.TRIGGER "svakt_func" ].

svinaktig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED svinaktig_prd ] !>,
    FLAGS.TRIGGER "svinaktig_func" ].

svint-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED svint_prd ] !>,
    FLAGS.TRIGGER "svint_func" ].

svært-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED svært_prd ] !>,
    FLAGS.TRIGGER "svært_func" ].

syd*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED syd*for_prd ] !>,
    FLAGS.TRIGGER "syd*for_func" ].

syd-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED syd_prd ] !>,
    FLAGS.TRIGGER "syd_func" ].

sydfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydfra_prd ] !>,
    FLAGS.TRIGGER "sydfra_func" ].

sydost-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydost_prd ] !>,
    FLAGS.TRIGGER "sydost_func" ].

sydover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydover_prd ] !>,
    FLAGS.TRIGGER "sydover_func" ].

sydvest*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydvest*for_prd ] !>,
    FLAGS.TRIGGER "sydvest*for_func" ].

sydvest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydvest_prd ] !>,
    FLAGS.TRIGGER "sydvest_func" ].

sydvestover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydvestover_prd ] !>,
    FLAGS.TRIGGER "sydvestover_func" ].

sydøst*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydøst*for_prd ] !>,
    FLAGS.TRIGGER "sydøst*for_func" ].

sydøst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydøst_prd ] !>,
    FLAGS.TRIGGER "sydøst_func" ].

sydøstover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sydøstover_prd ] !>,
    FLAGS.TRIGGER "sydøstover_func" ].

sykt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sykt_prd ] !>,
    FLAGS.TRIGGER "sykt_func" ].

synderlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED synderlig_prd ] !>,
    FLAGS.TRIGGER "synderlig_func" ].

sØ*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sØ*for_prd ] !>,
    FLAGS.TRIGGER "sØ*for_func" ].

så*godt*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*godt*som_prd ] !>,
    FLAGS.TRIGGER "så*godt*som_func" ].

så*langt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*langt_prd ] !>,
    FLAGS.TRIGGER "så*langt_func" ].

så*lenge-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*lenge_prd ] !>,
    FLAGS.TRIGGER "så*lenge_func" ].

så*og*si-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*og*si_prd ] !>,
    FLAGS.TRIGGER "så*og*si_func" ].

så*snart-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*snart_prd ] !>,
    FLAGS.TRIGGER "så*snart_func" ].

så*vel*som-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*vel*som_prd ] !>,
    FLAGS.TRIGGER "så*vel*som_func" ].

så*vidt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*vidt_prd ] !>,
    FLAGS.TRIGGER "så*vidt_func" ].

så*å*si-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så*å*si_prd ] !>,
    FLAGS.TRIGGER "så*å*si_func" ].

så-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED så_prd ] !>,
    FLAGS.TRIGGER "så_func" ].

såfremt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såfremt_prd ] !>,
    FLAGS.TRIGGER "såfremt_func" ].

sågar-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sågar_prd ] !>,
    FLAGS.TRIGGER "sågar_func" ].

såkalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såkalt_prd ] !>,
    FLAGS.TRIGGER "såkalt_func" ].

således-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED således_prd ] !>,
    FLAGS.TRIGGER "således_func" ].

såleis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såleis_prd ] !>,
    FLAGS.TRIGGER "såleis_func" ].

sånn*at-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sånn*at_prd ] !>,
    FLAGS.TRIGGER "sånn*at_func" ].

sånn*sett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sånn*sett_prd ] !>,
    FLAGS.TRIGGER "sånn*sett_func" ].

sånn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sånn_prd ] !>,
    FLAGS.TRIGGER "sånn_func" ].

såpass*at-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såpass*at_prd ] !>,
    FLAGS.TRIGGER "såpass*at_func" ].

såpass-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såpass_prd ] !>,
    FLAGS.TRIGGER "såpass_func" ].

såre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såre_prd ] !>,
    FLAGS.TRIGGER "såre_func" ].

såvidt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såvidt_prd ] !>,
    FLAGS.TRIGGER "såvidt_func" ].

såvisst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED såvisst_prd ] !>,
    FLAGS.TRIGGER "såvisst_func" ].

særdeles-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED særdeles_prd ] !>,
    FLAGS.TRIGGER "særdeles_func" ].

særlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED særlig_prd ] !>,
    FLAGS.TRIGGER "særlig_func" ].

særs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED særs_prd ] !>,
    FLAGS.TRIGGER "særs_func" ].

søkk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED søkk_prd ] !>,
    FLAGS.TRIGGER "søkk_func" ].

søkkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED søkkende_prd ] !>,
    FLAGS.TRIGGER "søkkende_func" ].

sømmelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sømmelig_prd ] !>,
    FLAGS.TRIGGER "sømmelig_func" ].

sønder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sønder_prd ] !>,
    FLAGS.TRIGGER "sønder_func" ].

sønna-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sønna_prd ] !>,
    FLAGS.TRIGGER "sønna_func" ].

sønnafjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sønnafjells_prd ] !>,
    FLAGS.TRIGGER "sønnafjells_func" ].

sønnenfjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sønnenfjells_prd ] !>,
    FLAGS.TRIGGER "sønnenfjells_func" ].

sør*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sør*for_prd ] !>,
    FLAGS.TRIGGER "sør*for_func" ].

sør-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sør_prd ] !>,
    FLAGS.TRIGGER "sør_func" ].

søraust-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED søraust_prd ] !>,
    FLAGS.TRIGGER "søraust_func" ].

sørfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørfra_prd ] !>,
    FLAGS.TRIGGER "sørfra_func" ].

sørgelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørgelig_prd ] !>,
    FLAGS.TRIGGER "sørgelig_func" ].

sørover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørover_prd ] !>,
    FLAGS.TRIGGER "sørover_func" ].

sørpe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørpe_prd ] !>,
    FLAGS.TRIGGER "sørpe_func" ].

sørpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørpå_prd ] !>,
    FLAGS.TRIGGER "sørpå_func" ].

sørvest*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørvest*for_prd ] !>,
    FLAGS.TRIGGER "sørvest*for_func" ].

sørvest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørvest_prd ] !>,
    FLAGS.TRIGGER "sørvest_func" ].

sørvestover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørvestover_prd ] !>,
    FLAGS.TRIGGER "sørvestover_func" ].

sørøst*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørøst*for_prd ] !>,
    FLAGS.TRIGGER "sørøst*for_func" ].

sørøst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørøst_prd ] !>,
    FLAGS.TRIGGER "sørøst_func" ].

sørøstover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED sørøstover_prd ] !>,
    FLAGS.TRIGGER "sørøstover_func" ].

t*slash*r-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED t*slash*r_prd ] !>,
    FLAGS.TRIGGER "t*slash*r_func" ].

tak-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tak_prd ] !>,
    FLAGS.TRIGGER "tak_func" ].

takimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED takimellom_prd ] !>,
    FLAGS.TRIGGER "takimellom_func" ].

takket*være-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED takket*være_prd ] !>,
    FLAGS.TRIGGER "takket*være_func" ].

takomtil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED takomtil_prd ] !>,
    FLAGS.TRIGGER "takomtil_func" ].

tallet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tallet_prd ] !>,
    FLAGS.TRIGGER "tallet_func" ].

tante-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tante_prd ] !>,
    FLAGS.TRIGGER "tante_func" ].

temmelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED temmelig_prd ] !>,
    FLAGS.TRIGGER "temmelig_func" ].

tett*i*tett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tett*i*tett_prd ] !>,
    FLAGS.TRIGGER "tett*i*tett_func" ].

tett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tett_prd ] !>,
    FLAGS.TRIGGER "tett_func" ].

ti-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ti_prd ] !>,
    FLAGS.TRIGGER "ti_func" ].

tidlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tidlig_prd ] !>,
    FLAGS.TRIGGER "tidlig_func" ].

tidligdags-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tidligdags_prd ] !>,
    FLAGS.TRIGGER "tidligdags_func" ].

tidligere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tidligere_prd ] !>,
    FLAGS.TRIGGER "tidligere_func" ].

tidsnok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tidsnok_prd ] !>,
    FLAGS.TRIGGER "tidsnok_func" ].

tidvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tidvis_prd ] !>,
    FLAGS.TRIGGER "tidvis_func" ].

til*bords-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*bords_prd ] !>,
    FLAGS.TRIGGER "til*bords_func" ].

til*bunns-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*bunns_prd ] !>,
    FLAGS.TRIGGER "til*bunns_func" ].

til*dels-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*dels_prd ] !>,
    FLAGS.TRIGGER "til*dels_func" ].

til*fjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*fjells_prd ] !>,
    FLAGS.TRIGGER "til*fjells_func" ].

til*fots-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*fots_prd ] !>,
    FLAGS.TRIGGER "til*fots_func" ].

til*gards-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*gards_prd ] !>,
    FLAGS.TRIGGER "til*gards_func" ].

til*gode-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*gode_prd ] !>,
    FLAGS.TRIGGER "til*gode_func" ].

til*grunn-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*grunn_prd ] !>,
    FLAGS.TRIGGER "til*grunn_func" ].

til*gårds-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*gårds_prd ] !>,
    FLAGS.TRIGGER "til*gårds_func" ].

til*hensikt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*hensikt_prd ] !>,
    FLAGS.TRIGGER "til*hensikt_func" ].

til*høyre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*høyre_prd ] !>,
    FLAGS.TRIGGER "til*høyre_func" ].

til*køys-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*køys_prd ] !>,
    FLAGS.TRIGGER "til*køys_func" ].

til*lands-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*lands_prd ] !>,
    FLAGS.TRIGGER "til*lands_func" ].

til*livs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*livs_prd ] !>,
    FLAGS.TRIGGER "til*livs_func" ].

til*låns-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*låns_prd ] !>,
    FLAGS.TRIGGER "til*låns_func" ].

til*og*fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*og*fra_prd ] !>,
    FLAGS.TRIGGER "til*og*fra_func" ].

til*og*med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*og*med_prd ] !>,
    FLAGS.TRIGGER "til*og*med_func" ].

til*overs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*overs_prd ] !>,
    FLAGS.TRIGGER "til*overs_func" ].

til*rette-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*rette_prd ] !>,
    FLAGS.TRIGGER "til*rette_func" ].

til*ro-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*ro_prd ] !>,
    FLAGS.TRIGGER "til*ro_func" ].

til*sammen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*sammen_prd ] !>,
    FLAGS.TRIGGER "til*sammen_func" ].

til*side-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*side_prd ] !>,
    FLAGS.TRIGGER "til*side_func" ].

til*sides-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*sides_prd ] !>,
    FLAGS.TRIGGER "til*sides_func" ].

til*sist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*sist_prd ] !>,
    FLAGS.TRIGGER "til*sist_func" ].

til*sjøs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*sjøs_prd ] !>,
    FLAGS.TRIGGER "til*sjøs_func" ].

til*slutt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*slutt_prd ] !>,
    FLAGS.TRIGGER "til*slutt_func" ].

til*syne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*syne_prd ] !>,
    FLAGS.TRIGGER "til*syne_func" ].

til*syvende*og*sist-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*syvende*og*sist_prd ] !>,
    FLAGS.TRIGGER "til*syvende*og*sist_func" ].

til*tider-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*tider_prd ] !>,
    FLAGS.TRIGGER "til*tider_func" ].

til*topps-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*topps_prd ] !>,
    FLAGS.TRIGGER "til*topps_func" ].

til*tross*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*tross*for_prd ] !>,
    FLAGS.TRIGGER "til*tross*for_func" ].

til*vanlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*vanlig_prd ] !>,
    FLAGS.TRIGGER "til*vanlig_func" ].

til*vanns-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*vanns_prd ] !>,
    FLAGS.TRIGGER "til*vanns_func" ].

til*venstre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*venstre_prd ] !>,
    FLAGS.TRIGGER "til*venstre_func" ].

til*værs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*værs_prd ] !>,
    FLAGS.TRIGGER "til*værs_func" ].

til*å*begynne*med-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til*å*begynne*med_prd ] !>,
    FLAGS.TRIGGER "til*å*begynne*med_func" ].

til-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED til_prd ] !>,
    FLAGS.TRIGGER "til_func" ].

tilbake-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilbake_prd ] !>,
    FLAGS.TRIGGER "tilbake_func" ].

tildels-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tildels_prd ] !>,
    FLAGS.TRIGGER "tildels_func" ].

tilfeldigvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilfeldigvis_prd ] !>,
    FLAGS.TRIGGER "tilfeldigvis_func" ].

tillike-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tillike_prd ] !>,
    FLAGS.TRIGGER "tillike_func" ].

tilmed-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilmed_prd ] !>,
    FLAGS.TRIGGER "tilmed_func" ].

tilnærmelsesvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilnærmelsesvis_prd ] !>,
    FLAGS.TRIGGER "tilnærmelsesvis_func" ].

tilnærmet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilnærmet_prd ] !>,
    FLAGS.TRIGGER "tilnærmet_func" ].

tilsammen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilsammen_prd ] !>,
    FLAGS.TRIGGER "tilsammen_func" ].

tilsynelatende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tilsynelatende_prd ] !>,
    FLAGS.TRIGGER "tilsynelatende_func" ].

timevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED timevis_prd ] !>,
    FLAGS.TRIGGER "timevis_func" ].

tindrende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tindrende_prd ] !>,
    FLAGS.TRIGGER "tindrende_func" ].

titt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED titt_prd ] !>,
    FLAGS.TRIGGER "titt_func" ].

tjokkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tjokkende_prd ] !>,
    FLAGS.TRIGGER "tjokkende_func" ].

tomreipes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tomreipes_prd ] !>,
    FLAGS.TRIGGER "tomreipes_func" ].

topologisk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED topologisk_prd ] !>,
    FLAGS.TRIGGER "topologisk_func" ].

topp-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED topp_prd ] !>,
    FLAGS.TRIGGER "topp_func" ].

totalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED totalt_prd ] !>,
    FLAGS.TRIGGER "totalt_func" ].

tott-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tott_prd ] !>,
    FLAGS.TRIGGER "tott_func" ].

tperiodvperiod-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tperiodvperiod_prd ] !>,
    FLAGS.TRIGGER "tperiodvperiod_func" ].

tradisjonelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tradisjonelt_prd ] !>,
    FLAGS.TRIGGER "tradisjonelt_func" ].

tradisjonen*tro-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tradisjonen*tro_prd ] !>,
    FLAGS.TRIGGER "tradisjonen*tro_func" ].

trass*i-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED trass*i_prd ] !>,
    FLAGS.TRIGGER "trass*i_func" ].

trill-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED trill_prd ] !>,
    FLAGS.TRIGGER "trill_func" ].

trillende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED trillende_prd ] !>,
    FLAGS.TRIGGER "trillende_func" ].

trinnvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED trinnvis_prd ] !>,
    FLAGS.TRIGGER "trinnvis_func" ].

troppevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED troppevis_prd ] !>,
    FLAGS.TRIGGER "troppevis_func" ].

troppo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED troppo_prd ] !>,
    FLAGS.TRIGGER "troppo_func" ].

troppsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED troppsvis_prd ] !>,
    FLAGS.TRIGGER "troppsvis_func" ].

tross*alt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tross*alt_prd ] !>,
    FLAGS.TRIGGER "tross*alt_func" ].

tross*at-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tross*at_prd ] !>,
    FLAGS.TRIGGER "tross*at_func" ].

tross-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tross_prd ] !>,
    FLAGS.TRIGGER "tross_func" ].

trutt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED trutt_prd ] !>,
    FLAGS.TRIGGER "trutt_func" ].

trykkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED trykkende_prd ] !>,
    FLAGS.TRIGGER "trykkende_func" ].

tslashr-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tslashr_prd ] !>,
    FLAGS.TRIGGER "tslashr_func" ].

tur*slash*retur-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tur*slash*retur_prd ] !>,
    FLAGS.TRIGGER "tur*slash*retur_func" ].

turevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED turevis_prd ] !>,
    FLAGS.TRIGGER "turevis_func" ].

turvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED turvis_prd ] !>,
    FLAGS.TRIGGER "turvis_func" ].

tusenfold-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tusenfold_prd ] !>,
    FLAGS.TRIGGER "tusenfold_func" ].

tusenvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tusenvis_prd ] !>,
    FLAGS.TRIGGER "tusenvis_func" ].

tvers*over-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tvers*over_prd ] !>,
    FLAGS.TRIGGER "tvers*over_func" ].

tvers-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tvers_prd ] !>,
    FLAGS.TRIGGER "tvers_func" ].

tvert*imot-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tvert*imot_prd ] !>,
    FLAGS.TRIGGER "tvert*imot_func" ].

tvert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tvert_prd ] !>,
    FLAGS.TRIGGER "tvert_func" ].

tvingende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tvingende_prd ] !>,
    FLAGS.TRIGGER "tvingende_func" ].

tydeligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tydeligvis_prd ] !>,
    FLAGS.TRIGGER "tydeligvis_func" ].

tynnevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tynnevis_prd ] !>,
    FLAGS.TRIGGER "tynnevis_func" ].

typisk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED typisk_prd ] !>,
    FLAGS.TRIGGER "typisk_func" ].

tålig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tålig_prd ] !>,
    FLAGS.TRIGGER "tålig_func" ].

tønnevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED tønnevis_prd ] !>,
    FLAGS.TRIGGER "tønnevis_func" ].

u*slash-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED u*slash_prd ] !>,
    FLAGS.TRIGGER "u*slash_func" ].

uakseptabelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uakseptabelt_prd ] !>,
    FLAGS.TRIGGER "uakseptabelt_func" ].

ualminnelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ualminnelig_prd ] !>,
    FLAGS.TRIGGER "ualminnelig_func" ].

uansett-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uansett_prd ] !>,
    FLAGS.TRIGGER "uansett_func" ].

ubehagelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ubehagelig_prd ] !>,
    FLAGS.TRIGGER "ubehagelig_func" ].

ubeskrivelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ubeskrivelig_prd ] !>,
    FLAGS.TRIGGER "ubeskrivelig_func" ].

ubetalelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ubetalelig_prd ] !>,
    FLAGS.TRIGGER "ubetalelig_func" ].

udelt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED udelt_prd ] !>,
    FLAGS.TRIGGER "udelt_func" ].

uendelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uendelig_prd ] !>,
    FLAGS.TRIGGER "uendelig_func" ].

ufordragelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ufordragelig_prd ] !>,
    FLAGS.TRIGGER "ufordragelig_func" ].

uforholdsmessig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uforholdsmessig_prd ] !>,
    FLAGS.TRIGGER "uforholdsmessig_func" ].

uforskammet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uforskammet_prd ] !>,
    FLAGS.TRIGGER "uforskammet_func" ].

ufravendt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ufravendt_prd ] !>,
    FLAGS.TRIGGER "ufravendt_func" ].

ugjerne-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ugjerne_prd ] !>,
    FLAGS.TRIGGER "ugjerne_func" ].

uheldigvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uheldigvis_prd ] !>,
    FLAGS.TRIGGER "uheldigvis_func" ].

uhyre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uhyre_prd ] !>,
    FLAGS.TRIGGER "uhyre_func" ].

uhyrlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uhyrlig_prd ] !>,
    FLAGS.TRIGGER "uhyrlig_func" ].

ukevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ukevis_prd ] !>,
    FLAGS.TRIGGER "ukevis_func" ].

ultimo-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ultimo_prd ] !>,
    FLAGS.TRIGGER "ultimo_func" ].

ulykkeligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ulykkeligvis_prd ] !>,
    FLAGS.TRIGGER "ulykkeligvis_func" ].

uløyves-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uløyves_prd ] !>,
    FLAGS.TRIGGER "uløyves_func" ].

umåtelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED umåtelig_prd ] !>,
    FLAGS.TRIGGER "umåtelig_func" ].

under-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED under_prd ] !>,
    FLAGS.TRIGGER "under_func" ].

underhånden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED underhånden_prd ] !>,
    FLAGS.TRIGGER "underhånden_func" ].

underlig*nok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED underlig*nok_prd ] !>,
    FLAGS.TRIGGER "underlig*nok_func" ].

underlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED underlig_prd ] !>,
    FLAGS.TRIGGER "underlig_func" ].

undertiden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED undertiden_prd ] !>,
    FLAGS.TRIGGER "undertiden_func" ].

undervegs-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED undervegs_prd ] !>,
    FLAGS.TRIGGER "undervegs_func" ].

underveis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED underveis_prd ] !>,
    FLAGS.TRIGGER "underveis_func" ].

unna-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unna_prd ] !>,
    FLAGS.TRIGGER "unna_func" ].

unntagelsesvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unntagelsesvis_prd ] !>,
    FLAGS.TRIGGER "unntagelsesvis_func" ].

unntagen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unntagen_prd ] !>,
    FLAGS.TRIGGER "unntagen_func" ].

unntakelsesvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unntakelsesvis_prd ] !>,
    FLAGS.TRIGGER "unntakelsesvis_func" ].

unntaksvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unntaksvis_prd ] !>,
    FLAGS.TRIGGER "unntaksvis_func" ].

unntatt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unntatt_prd ] !>,
    FLAGS.TRIGGER "unntatt_func" ].

unormalt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED unormalt_prd ] !>,
    FLAGS.TRIGGER "unormalt_func" ].

urovekkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED urovekkende_prd ] !>,
    FLAGS.TRIGGER "urovekkende_func" ].

usedvanlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED usedvanlig_prd ] !>,
    FLAGS.TRIGGER "usedvanlig_func" ].

ustyrtelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ustyrtelig_prd ] !>,
    FLAGS.TRIGGER "ustyrtelig_func" ].

ut*fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ut*fra_prd ] !>,
    FLAGS.TRIGGER "ut*fra_func" ].

ut-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ut_prd ] !>,
    FLAGS.TRIGGER "ut_func" ].

utaboks-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utaboks_prd ] !>,
    FLAGS.TRIGGER "utaboks_func" ].

utad-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utad_prd ] !>,
    FLAGS.TRIGGER "utad_func" ].

utafor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utafor_prd ] !>,
    FLAGS.TRIGGER "utafor_func" ].

utalands-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utalands_prd ] !>,
    FLAGS.TRIGGER "utalands_func" ].

utapå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utapå_prd ] !>,
    FLAGS.TRIGGER "utapå_func" ].

utbygdes-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utbygdes_prd ] !>,
    FLAGS.TRIGGER "utbygdes_func" ].

utdragsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utdragsvis_prd ] !>,
    FLAGS.TRIGGER "utdragsvis_func" ].

ute-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ute_prd ] !>,
    FLAGS.TRIGGER "ute_func" ].

utelukkende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utelukkende_prd ] !>,
    FLAGS.TRIGGER "utelukkende_func" ].

uten*tvil-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uten*tvil_prd ] !>,
    FLAGS.TRIGGER "uten*tvil_func" ].

uten*videre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uten*videre_prd ] !>,
    FLAGS.TRIGGER "uten*videre_func" ].

uten-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uten_prd ] !>,
    FLAGS.TRIGGER "uten_func" ].

utenat-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenat_prd ] !>,
    FLAGS.TRIGGER "utenat_func" ].

utenboks-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenboks_prd ] !>,
    FLAGS.TRIGGER "utenboks_func" ].

utenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenfor_prd ] !>,
    FLAGS.TRIGGER "utenfor_func" ].

utenfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenfra_prd ] !>,
    FLAGS.TRIGGER "utenfra_func" ].

utenlands-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenlands_prd ] !>,
    FLAGS.TRIGGER "utenlands_func" ].

utenom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenom_prd ] !>,
    FLAGS.TRIGGER "utenom_func" ].

utenpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utenpå_prd ] !>,
    FLAGS.TRIGGER "utenpå_func" ].

utfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utfor_prd ] !>,
    FLAGS.TRIGGER "utfor_func" ].

uti-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uti_prd ] !>,
    FLAGS.TRIGGER "uti_func" ].

utomhus-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utomhus_prd ] !>,
    FLAGS.TRIGGER "utomhus_func" ].

utover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utover_prd ] !>,
    FLAGS.TRIGGER "utover_func" ].

utpreget-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utpreget_prd ] !>,
    FLAGS.TRIGGER "utpreget_func" ].

utpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utpå_prd ] !>,
    FLAGS.TRIGGER "utpå_func" ].

utrolig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utrolig_prd ] !>,
    FLAGS.TRIGGER "utrolig_func" ].

utsøkt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utsøkt_prd ] !>,
    FLAGS.TRIGGER "utsøkt_func" ].

utvilsomt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED utvilsomt_prd ] !>,
    FLAGS.TRIGGER "utvilsomt_func" ].

uutholdelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uutholdelig_prd ] !>,
    FLAGS.TRIGGER "uutholdelig_func" ].

uvanlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uvanlig_prd ] !>,
    FLAGS.TRIGGER "uvanlig_func" ].

uvegerlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uvegerlig_prd ] !>,
    FLAGS.TRIGGER "uvegerlig_func" ].

uventet-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED uventet_prd ] !>,
    FLAGS.TRIGGER "uventet_func" ].

v*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED v*for_prd ] !>,
    FLAGS.TRIGGER "v*for_func" ].

v*i-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED v*i_prd ] !>,
    FLAGS.TRIGGER "v*i_func" ].

v-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED v_prd ] !>,
    FLAGS.TRIGGER "v_func" ].

vakkert-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vakkert_prd ] !>,
    FLAGS.TRIGGER "vakkert_func" ].

vanligvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vanligvis_prd ] !>,
    FLAGS.TRIGGER "vanligvis_func" ].

vann-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vann_prd ] !>,
    FLAGS.TRIGGER "vann_func" ].

vanvittig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vanvittig_prd ] !>,
    FLAGS.TRIGGER "vanvittig_func" ].

vare-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vare_prd ] !>,
    FLAGS.TRIGGER "vare_func" ].

ved*hjelp*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ved*hjelp*av_prd ] !>,
    FLAGS.TRIGGER "ved*hjelp*av_func" ].

ved*siden*av-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ved*siden*av_prd ] !>,
    FLAGS.TRIGGER "ved*siden*av_func" ].

ved-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ved_prd ] !>,
    FLAGS.TRIGGER "ved_func" ].

veggimellom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED veggimellom_prd ] !>,
    FLAGS.TRIGGER "veggimellom_func" ].

vekevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vekevis_prd ] !>,
    FLAGS.TRIGGER "vekevis_func" ].

vekk-fra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vekk-fra_prd ] !>,
    FLAGS.TRIGGER "vekk-fra_func" ].

vekk-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vekk_prd ] !>,
    FLAGS.TRIGGER "vekk_func" ].

vekke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vekke_prd ] !>,
    FLAGS.TRIGGER "vekke_func" ].

vekselsvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vekselsvis_prd ] !>,
    FLAGS.TRIGGER "vekselsvis_func" ].

vekselvis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vekselvis_prd ] !>,
    FLAGS.TRIGGER "vekselvis_func" ].

vel*å*merke-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vel*å*merke_prd ] !>,
    FLAGS.TRIGGER "vel*å*merke_func" ].

vel-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vel_prd ] !>,
    FLAGS.TRIGGER "vel_func" ].

veldig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED veldig_prd ] !>,
    FLAGS.TRIGGER "veldig_func" ].

venstre-leder-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED venstre-leder_prd ] !>,
    FLAGS.TRIGGER "venstre-leder_func" ].

vesentlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vesentlig_prd ] !>,
    FLAGS.TRIGGER "vesentlig_func" ].

vest*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vest*for_prd ] !>,
    FLAGS.TRIGGER "vest*for_func" ].

vest-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vest_prd ] !>,
    FLAGS.TRIGGER "vest_func" ].

vesta-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vesta_prd ] !>,
    FLAGS.TRIGGER "vesta_func" ].

vestafjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vestafjells_prd ] !>,
    FLAGS.TRIGGER "vestafjells_func" ].

vestenfjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vestenfjells_prd ] !>,
    FLAGS.TRIGGER "vestenfjells_func" ].

vestfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vestfra_prd ] !>,
    FLAGS.TRIGGER "vestfra_func" ].

vestover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vestover_prd ] !>,
    FLAGS.TRIGGER "vestover_func" ].

vestpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vestpå_prd ] !>,
    FLAGS.TRIGGER "vestpå_func" ].

via-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED via_prd ] !>,
    FLAGS.TRIGGER "via_func" ].

vibrato-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vibrato_prd ] !>,
    FLAGS.TRIGGER "vibrato_func" ].

vide-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vide_prd ] !>,
    FLAGS.TRIGGER "vide_func" ].

viden-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED viden_prd ] !>,
    FLAGS.TRIGGER "viden_func" ].

videre-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED videre_prd ] !>,
    FLAGS.TRIGGER "videre_func" ].

vidt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vidt_prd ] !>,
    FLAGS.TRIGGER "vidt_func" ].

vidunderlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vidunderlig_prd ] !>,
    FLAGS.TRIGGER "vidunderlig_func" ].

vilt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vilt_prd ] !>,
    FLAGS.TRIGGER "vilt_func" ].

vinterstid-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vinterstid_prd ] !>,
    FLAGS.TRIGGER "vinterstid_func" ].

virkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED virkelig_prd ] !>,
    FLAGS.TRIGGER "virkelig_func" ].

vis*à*vis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vis*à*vis_prd ] !>,
    FLAGS.TRIGGER "vis*à*vis_func" ].

vis-a-vis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vis-a-vis_prd ] !>,
    FLAGS.TRIGGER "vis-a-vis_func" ].

vis-à-vis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vis-à-vis_prd ] !>,
    FLAGS.TRIGGER "vis-à-vis_func" ].

viselig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED viselig_prd ] !>,
    FLAGS.TRIGGER "viselig_func" ].

viss-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED viss_prd ] !>,
    FLAGS.TRIGGER "viss_func" ].

visselig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED visselig_prd ] !>,
    FLAGS.TRIGGER "visselig_func" ].

visst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED visst_prd ] !>,
    FLAGS.TRIGGER "visst_func" ].

visstnok-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED visstnok_prd ] !>,
    FLAGS.TRIGGER "visstnok_func" ].

vivace-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vivace_prd ] !>,
    FLAGS.TRIGGER "vivace_func" ].

voldsomt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED voldsomt_prd ] !>,
    FLAGS.TRIGGER "voldsomt_func" ].

vondt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vondt_prd ] !>,
    FLAGS.TRIGGER "vondt_func" ].

vonlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vonlig_prd ] !>,
    FLAGS.TRIGGER "vonlig_func" ].

vonom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vonom_prd ] !>,
    FLAGS.TRIGGER "vonom_func" ].

vonoms-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vonoms_prd ] !>,
    FLAGS.TRIGGER "vonoms_func" ].

vrangsøles-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED vrangsøles_prd ] !>,
    FLAGS.TRIGGER "vrangsøles_func" ].

være-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED være_prd ] !>,
    FLAGS.TRIGGER "være_func" ].

ynkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ynkelig_prd ] !>,
    FLAGS.TRIGGER "ynkelig_func" ].

ytterlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ytterlig_prd ] !>,
    FLAGS.TRIGGER "ytterlig_func" ].

ytterligere-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ytterligere_prd ] !>,
    FLAGS.TRIGGER "ytterligere_func" ].

ytterst*ute-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ytterst*ute_prd ] !>,
    FLAGS.TRIGGER "ytterst*ute_func" ].

ytterst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ytterst_prd ] !>,
    FLAGS.TRIGGER "ytterst_func" ].

Ø*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED Ø*for_prd ] !>,
    FLAGS.TRIGGER "Ø*for_func" ].

Ø*i-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED Ø*i_prd ] !>,
    FLAGS.TRIGGER "Ø*i_func" ].

å-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED å_prd ] !>,
    FLAGS.TRIGGER "å_func" ].

åffer-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED åffer_prd ] !>,
    FLAGS.TRIGGER "åffer_func" ].

åkkesom-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED åkkesom_prd ] !>,
    FLAGS.TRIGGER "åkkesom_func" ].

åpenbart-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED åpenbart_prd ] !>,
    FLAGS.TRIGGER "åpenbart_func" ].

åpent-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED åpent_prd ] !>,
    FLAGS.TRIGGER "åpent_func" ].

årevis-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED årevis_prd ] !>,
    FLAGS.TRIGGER "årevis_func" ].

åssen-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED åssen_prd ] !>,
    FLAGS.TRIGGER "åssen_func" ].

ærlig*talt-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ærlig*talt_prd ] !>,
    FLAGS.TRIGGER "ærlig*talt_func" ].

én*etter*én-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED én*etter*én_prd ] !>,
    FLAGS.TRIGGER "én*etter*én_func" ].

én*for*én-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED én*for*én_prd ] !>,
    FLAGS.TRIGGER "én*for*én_func" ].

óg-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED óg_prd ] !>,
    FLAGS.TRIGGER "óg_func" ].

ørende-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED ørende_prd ] !>,
    FLAGS.TRIGGER "ørende_func" ].

øst*for-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øst*for_prd ] !>,
    FLAGS.TRIGGER "øst*for_func" ].

øst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øst_prd ] !>,
    FLAGS.TRIGGER "øst_func" ].

østa-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østa_prd ] !>,
    FLAGS.TRIGGER "østa_func" ].

østafjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østafjells_prd ] !>,
    FLAGS.TRIGGER "østafjells_func" ].

østenfjells-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østenfjells_prd ] !>,
    FLAGS.TRIGGER "østenfjells_func" ].

østenfor-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østenfor_prd ] !>,
    FLAGS.TRIGGER "østenfor_func" ].

østfra-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østfra_prd ] !>,
    FLAGS.TRIGGER "østfra_func" ].

østover-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østover_prd ] !>,
    FLAGS.TRIGGER "østover_func" ].

østpå-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED østpå_prd ] !>,
    FLAGS.TRIGGER "østpå_func" ].

øverst*oppe-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øverst*oppe_prd ] !>,
    FLAGS.TRIGGER "øverst*oppe_func" ].

øverst-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øverst_prd ] !>,
    FLAGS.TRIGGER "øverst_func" ].

øye-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øye_prd ] !>,
    FLAGS.TRIGGER "øye_func" ].

øyeblikkelig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øyeblikkelig_prd ] !>,
    FLAGS.TRIGGER "øyeblikkelig_func" ].

øyensynlig-func_rule := arg0e_gtr &
  [ CONTEXT.RELS <! [ PRED øyensynlig_prd ] !>,
    FLAGS.TRIGGER "øyensynlig_func" ].