A.9 Lexicon.oz

functor 
import Entry
export Get
define 
   Lexicon = {Dictionary.new}
   proc {PUT Word Spec}
      {Dictionary.put Lexicon Word
       {Entry.lexEncode Spec}|{Dictionary.condGet Lexicon Word nil}}
   end 
   fun {Get Word}
      try Lexicon.Word
      catch _ then 
         raise unknownword(Word) end 
      end 
   end 
   {PUT peter
    lex(cats            : [n]
        agrs            : [[masc sing 3 [nom acc dat]]]
        comps_opt       : [det])}
   {PUT peters
    lex(cats            : [n]
        agrs            : [[masc sing 3 gen]]
        comps_opt       : [det])}
   {PUT maria
    lex(cats            : [n]
        agrs            : [[fem sing 3 [nom acc dat]]]
        comps_opt       : [det])}
   {PUT marias
    lex(cats            : [n]
        agrs            : [[fem sing 3 gen]]
        comps_opt       : [det])}
   {PUT ich
    lex(cats            : [pro]
        agrs            : [[sing 1 nom]])}
   {PUT mich
    lex(cats            : [pro]
        agrs            : [[sing 1 acc]])}
   {PUT mir
    lex(cats            : [pro]
        agrs            : [[sing 1 dat]])}
   {PUT du
    lex(cats            : [pro]
        agrs            : [[sing 2 nom]])}
   {PUT dich
    lex(cats            : [pro]
        agrs            : [[sing 2 acc]])}
   {PUT dir
    lex(cats            : [pro]
        agrs            : [[sing 2 dat]])}
   {PUT er
    lex(cats            : [pro]
        agrs            : [[masc sing 3 nom]])}
   {PUT ihn
    lex(cats            : [pro]
        agrs            : [[masc sing 3 acc]])}
   {PUT ihm
    lex(cats            : [pro]
        agrs            : [[[masc neut] 3 dat]])}
   {PUT es
    lex(cats            : [pro]
        agrs            : [[neut sing 3 [nom acc]]])}
   {PUT sie
    lex(cats            : [pro]
        agrs            : [[fem sing 3 [nom acc]] [plur 3 [nom acc]]])}
   {PUT ihr
    lex(cats            : [pro]
        agrs            : [[fem sing 3 dat] [plur 2 nom]])}
   {PUT ihnen
    lex(cats            : [pro]
        agrs            : [[plur 3 dat]])}
   {PUT wir
    lex(cats            : [pro]
        agrs            : [[plur 1 nom]])}
   {PUT uns
    lex(cats            : [pro]
        agrs            : [[plur 1 [acc dat]]])}
   {PUT euch
    lex(cats            : [pro]
        agrs            : [[plur 2 [acc dat]]])}
   {PUT jemand
    lex(cats            : [pro]
        agrs            : [[sing 3 nom]])}
   {PUT jemanden
    lex(cats            : [pro]
        agrs            : [[sing 3 acc]])}
   {PUT jemandem
    lex(cats            : [pro]
        agrs            : [[sing 3 dat]])}
   {PUT frau
    lex(cats            : [n]
        agrs            : [[fem sing 3]]
        comps_opt       : [det])}
   {PUT frauen
    lex(cats            : [n]
        agrs            : [[fem plur 3]]
        comps_opt       : [det])}
   {PUT mann
    lex(cats            : [n]
        agrs            : [[masc 3 sing [nom acc dat]]]
        comps_opt       : [det])}
   {PUT mannes
    lex(cats            : [n]
        agrs            : [[masc 3 sing gen]]
        comps_opt       : [det])}
   {PUT männer
    lex(cats            : [n]
        agrs            : [[masc 3 plur [nom acc gen]]]
        comps_opt       : [det])}
   {PUT männern
    lex(cats            : [n]
        agrs            : [[masc 3 plur dat]]
        comps_opt       : [det])}
   {PUT buch
    lex(cats            : [n]
        agrs            : [[neut 3 sing [nom acc dat]]]
        comps_opt       : [det])}
   {PUT buches
    lex(cats            : [n]
        agrs            : [[neut 3 sing gen]]
        comps_opt       : [det])}
   {PUT bücher
    lex(cats            : [n]
        agrs            : [[neut 3 plur [nom acc gen]]]
        comps_opt       : [det])}
   {PUT büchern
    lex(cats            : [n]
        agrs            : [[neut 3 plur dat]]
        comps_opt       : [det])}
 
   {PUT richter
    lex(cats            : [n]
        agrs            : [[masc 3 sing [nom acc dat]]
                           [masc 3 plur [nom acc gen]]]
        comps_req       : [det])}
   {PUT richters
    lex(cats            : [n]
        agrs            : [[masc 3 sing gen]]
        comps_req       : [det])}
   {PUT richtern
    lex(cats            : [n]
        agrs            : [[masc 3 plur dat]]
        comps_opt       : [det])}
 
   {PUT tat
    lex(cats            : [n]
        agrs            : [[fem 3 sing]]
        comps_req       : [det])}
   {PUT taten
    lex(cats            : [n]
        agrs            : [[fem 3 plur]]
        comps_opt       : [det])}
 
   {PUT fahrrad
    lex(cats            : [n]
        agrs            : [[neut 3 sing [nom acc dat]]]
        comps_req       : [det])}
   {PUT fahrrads
    lex(cats            : [n]
        agrs            : [[neut 3 sing gen]]
        comps_req       : [det])}
   {PUT fahrräder
    lex(cats            : [n]
        agrs            : [[neut 3 plur [nom acc gen]]]
        comps_opt       : [det])}
   {PUT fahrrädern
    lex(cats            : [n]
        agrs            : [[neut 3 plur dat]]
        comps_opt       : [det])}
 
   {PUT wein
    lex(cats            : [n]
        agrs            : [[masc 3 sing [nom acc dat]]]
        comps_opt       : [det])}
   {PUT weins
    lex(cats            : [n]
        agrs            : [[masc 3 sing gen]]
        comps_opt       : [det])}
   {PUT weine
    lex(cats            : [n]
        agrs            : [[masc 3 plur [nom acc gen]]]
        comps_opt       : [det])}
   {PUT weine
    lex(cats            : [n]
        agrs            : [[masc 3 plur dat]]
        comps_req       : [det])}
   {PUT der
    lex(cats            : [det]
        agrs            : [[def [[masc sing 3 nom]
                                 [fem  sing 3 [dat gen]]
                                 [     plur 3 gen]]]])}
   {PUT den
    lex(cats            : [det]
        agrs            : [[def [[masc sing 3 acc]
                                 [     plur 3 dat]]]])}
   {PUT dem
    lex(cats            : [det]
        agrs            : [[def [[[masc neut] sing 3 dat]]]])}
   {PUT des
    lex(cats            : [det]
        agrs            : [[def [[[masc neut] sing 3 gen]]]])}
   {PUT die
    lex(cats            : [det]
        agrs            : [[def [[fem sing 3 [nom acc]]
                                 [    plur 3 [nom acc]]]]])}
   {PUT das
    lex(cats            : [det]
        agrs            : [[def [[neut sing 3 [nom acc]]]]])}
 
   {PUT ein
    lex(cats            : [det]
        agrs            : [[indef [[masc sing 3 nom]
                                   [neut sing 3 [nom acc]]]]])}
   {PUT einen
    lex(cats            : [det]
        agrs            : [[indef [[masc sing 3 acc]]]])}
   {PUT einem
    lex(cats            : [det]
        agrs            : [[indef [[[masc neut] sing 3 dat]]]])}
   {PUT eines
    lex(cats            : [det]
        agrs            : [[indef [[[masc neut] sing 3 gen]]]])}
   {PUT eine
    lex(cats            : [det]
        agrs            : [[indef [[fem sing 3 [nom acc]]]]])}
   {PUT einer
    lex(cats            : [det]
        agrs            : [[indef [[fem sing 3 [dat gen]]]]])}
   {PUT lieben
    lex(cats            : [vinf]
        comps_opt       : [zu object])}
   {PUT liebe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT liebst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT liebt
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT lieben
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT liebet
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT geliebt
    lex(cats            : [vpast]
        comps_opt       : [object]
        marks           : [haben])}
 
   {PUT laufen
    lex(cats            : [vinf]
        comps_opt       : [zu])}
   {PUT laufe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]])}
   {PUT laufst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]])}
   {PUT lauft
    lex(cats            : [vfin]
        agrs            : [[3 sing nom] [2 plur nom]])}
   {PUT laufen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]])}
   {PUT gelaufen
    lex(cats            : [vpast]
        marks           : [sein])}
 
   {PUT lesen
    lex(cats            : [vinf]
        comps_opt       : [zu object])}
   {PUT lese
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT liest
    lex(cats            : [vfin]
        agrs            : [[[2 3] sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT lesen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT leset
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT gelesen
    lex(cats            : [vpast]
        comps_opt       : [object]
        marks           : [haben])}
 
   {PUT versprechen
    lex(cats            : [vinf]
        comps_opt       : [zu object dative])}
   {PUT versprechen
    lex(cats            : [vinf]
        comps_req       : [vp_zu]
        comps_opt       : [zu dative])}
   {PUT verspreche
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT verspreche
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT versprichst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT versprichst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT verspricht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT verspricht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT versprechen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT versprechen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT versprechet
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT versprechet
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT versprochen
    lex(cats            : [vpast]
        comps_opt       : [object dative]
        marks           : [haben])}
   {PUT versprochen
    lex(cats            : [vpast]
        comps_req       : [vp_zu]
        comps_opt       : [dative]
        marks           : [haben])}
 
   {PUT kaufen
    lex(cats            : [vinf]
        comps_opt       : [zu object dative])}
   {PUT kaufe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT kaufst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT kauft
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT kaufen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT gekauft
    lex(cats            : [vpast]
        comps_opt       : [object dative]
        marks           : [haben])}
 
   {PUT einkaufen
    lex(cats            : [vinf]
        comps_opt       : [zu object dative]
        marks           : [vpref])}
   {PUT einzukaufen
    lex(cats            : [vinf]
        comps_opt       : [object dative]
        marks           : [vpref zu])}
   {PUT kaufe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        vpref           : [ein]
        comps_req       : [subject vpref]
        comps_opt       : [object dative])}
   {PUT einkaufe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative]
        marks           : [vpref])}
   {PUT kaufst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        vpref           : [ein]
        comps_req       : [subject vpref]
        comps_opt       : [object dative])}
   {PUT einkaufst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative]
        marks           : [vpref])}
   {PUT kauft
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        vpref           : [ein]
        comps_req       : [subject vpref]
        comps_opt       : [object dative])}
   {PUT einkauft
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative]
        marks           : [vpref])}
   {PUT kaufen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        vpref           : [ein]
        comps_req       : [subject vpref]
        comps_opt       : [object dative])}
   {PUT einkaufen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative]
        marks           : [vpref])}
   {PUT eingekauft
    lex(cats            : [vpast]
        comps_opt       : [object dative]
        marks           : [vpref])}
   {PUT versuchen
    lex(cats            : [vinf]
        comps_opt       : [zu object])}
   {PUT versuchen
    lex(cats            : [vinf]
        comps_opt       : [zu]
        comps_req       : [vp_zu])}
   {PUT versuche
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT versuche
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject vp_zu])}
   {PUT versuchst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT versuchst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject vp_zu])}
   {PUT versucht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT versucht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        comps_req       : [subject vp_zu])}
   {PUT versuchen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT versuchen
    lex(cats            : [vfin]
        agrs            : [[[ 3] plur nom]]
        comps_req       : [subject vp_zu])}
   {PUT versucht
    lex(cats            : [vpast]
        comps_opt       : [object]
        marks           : [haben])}
   {PUT versucht
    lex(cats            : [vpast]
        comps_req       : [vp_zu]
        marks           : [haben])}
 
   {PUT behaupten
    lex(cats            : [vinf]
        comps_opt       : [zu vp_zu])}
   {PUT behaupte
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [vp_zu])}
   {PUT behauptest
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [vp_zu])}
   {PUT behauptet
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [vp_zu])}
   {PUT behaupten
    lex(cats            : [vfin]
        agrs            : [[1 plur nom][3 plur nom]]
        comps_req       : [subject]
        comps_opt       : [vp_zu])}
   {PUT behauptet
    lex(cats            : [vpast]
        comps_opt       : [vp_zu]
        marks           : [haben])}
 
   {PUT schenken
    lex(cats            : [vinf]
        comps_opt       : [zu object dative])}
   {PUT schenke
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT schenkst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT schenkt
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT schenken
    lex(cats            : [vfin]
        agrs            : [[1 plur nom][3 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT schenket
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT getschenkt
    lex(cats            : [vpast]
        comps_opt       : [object dative]
        marks           : [haben])}
 
   {PUT gestehen
    lex(cats            : [vinf]
        comps_opt       : [zu object dative])}
   {PUT gestehen
    lex(cats            : [vinf]
        comps_req       : [vp_zu]
        comps_opt       : [zu dative])}
   {PUT gestehe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT gestehe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT gestehst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT gestehst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT gesteht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT gesteht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT gestehen
    lex(cats            : [vfin]
        agrs            : [[1 plur nom][3 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT gestehen
    lex(cats            : [vfin]
        agrs            : [[1 plur nom][3 plur nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT gestehet
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object dative])}
   {PUT gestehet
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject vp_zu]
        comps_opt       : [dative])}
   {PUT gestanden
    lex(cats            : [vpast]
        comps_opt       : [object dative])}
   {PUT gestanden
    lex(cats            : [vpast]
        comps_req       : [vp_zu]
        comps_opt       : [dative])}
 
   {PUT begehen
    lex(cats            : [vinf]
        comps_opt       : [zu]
        comps_req       : [object])}
   {PUT begehe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject object])}
   {PUT begehst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject object])}
   {PUT begeht
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject object])}
   {PUT begehen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject object])}
   {PUT begehet
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject object])}
   {PUT begangen
    lex(cats            : [vpast]
        comps_req       : [object]
        marks           : [haben])}
 
   {PUT reparieren
    lex(cats            : [vinf]
        comps_opt       : [zu object])}
   {PUT repariere
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT reparierst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT repariert
    lex(cats            : [vfin]
        agrs            : [[3 sing nom][2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT reparieren
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT repariert
    lex(cats            : [vpast]
        comps_opt       : [object]
        marks           : [haben])}
   {PUT haben
    lex(cats            : [vinf]
        comps_opt       : [zu object])}
   {PUT habe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT hast
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT hat
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT haben
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT habt
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT gehabt
    lex(cats            : [vpast]
        comps_opt       : [object]
        marks           : [haben])}
 
   {PUT haben
    lex(cats            : [vinf]
        aux             : [haben]
        comps_opt       : [zu]
        comps_req       : [vp_past])}
   {PUT habe
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        aux             : [haben]
        comps_req       : [subject vp_past])}
   {PUT hast
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        aux             : [haben]
        comps_req       : [subject vp_past])}
   {PUT hat
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        aux             : [haben]
        comps_req       : [subject vp_past])}
   {PUT haben
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        aux             : [haben]
        comps_req       : [subject vp_past])}
   {PUT habt
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        aux             : [haben]
        comps_req       : [subject vp_past])}
   {PUT gehabt
    lex(cats            : [vpast]
        aux             : [haben]
        comps_req       : [vp_past]
        marks           : [haben])}
 
   {PUT sein
    lex(cats            : [vinf]
        comps_opt       : [zu nominative])}
   {PUT bin
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        comps_req       : [subject]
        comps_opt       : [nominative])}
   {PUT bist
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [nominative])}
   {PUT ist
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        comps_req       : [subject]
        comps_opt       : [nominative])}
   {PUT sind
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [nominative])}
   {PUT seid
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [nominative])}
   {PUT gewesen
    lex(cats            : [vpast]
        comps_opt       : [nominative]
        marks           : [sein])}
 
   {PUT sein
    lex(cats            : [vinf]
        aux             : [sein]
        comps_opt       : [zu]
        comps_req       : [vp_past])}
   {PUT bin
    lex(cats            : [vfin]
        agrs            : [[1 sing nom]]
        aux             : [sein]
        comps_req       : [subject vp_past])}
   {PUT bist
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        aux             : [sein]
        comps_req       : [subject vp_past])}
   {PUT ist
    lex(cats            : [vfin]
        agrs            : [[3 sing nom]]
        aux             : [sein]
        comps_req       : [subject vp_past])}
   {PUT sind
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        aux             : [sein]
        comps_req       : [subject vp_past])}
   {PUT seid
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        aux             : [sein]
        comps_req       : [subject vp_past])}
   {PUT gewesen
    lex(cats            : [vpast]
        aux             : [sein]
        comps_req       : [vp_past]
        marks           : [sein])}
   {PUT wollen
    lex(cats            : [vinf]
        comps_opt       : [zu object])}
   {PUT wollen
    lex(cats            : [vinf]
        comps_opt       : [zu]
        comps_req       : [vp_inf])}
   {PUT will
    lex(cats            : [vfin]
        agrs            : [[[1 3] sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT will
    lex(cats            : [vfin]
        agrs            : [[[1 3] sing nom]]
        comps_req       : [subject vp_inf])}
   {PUT willst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT willst
    lex(cats            : [vfin]
        agrs            : [[2 sing nom]]
        comps_req       : [subject vp_inf])}
   {PUT wollen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT wollen
    lex(cats            : [vfin]
        agrs            : [[[1 3] plur nom]]
        comps_req       : [subject vp_inf])}
   {PUT wollt
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject]
        comps_opt       : [object])}
   {PUT wollt
    lex(cats            : [vfin]
        agrs            : [[2 plur nom]]
        comps_req       : [subject vp_inf])}
   {PUT gewollt
    lex(cats            : [vpast]
        comps_opt       : [object]
        marks           : [haben])}
   {PUT gewollt
    lex(cats            : [vpast]
        comps_req       : [vp_inf]
        marks           : [haben])}
   {PUT schöne
    lex(cats            : [adj]
        agrs            : [[none  [nom acc] [fem plur]]
                           [def   sing [nom [acc [neut fem]]]]
                           [indef plur [nom acc]]])}
   {PUT schönen
    lex(cats            : [adj]
        agrs            : [[none  [[masc sing [acc gen]]
                                   [fem  sing gen]
                                   [plur dat]]]
                           [def   [plur dat gen [masc sing acc]]]
                           [indef sing [dat gen [masc acc]]]])}
   {PUT schöner
    lex(cats            : [adj]
        agrs            : [[none  [[masc sing nom]
                                   [fem sing [dat gen]]
                                   [plur gen]]]
                           [indef sing masc nom]])}
   {PUT schönes
    lex(cats            : [adj]
        agrs            : [[neut sing [nom acc] [indef none]]])}
   {PUT schönem
    lex(cats            : [adj]
        agrs            : [[[masc neut] sing dat none]])}
 
   {PUT große
    lex(cats            : [adj]
        agrs            : [[none  [nom acc] [fem plur]]
                           [def   sing [nom [acc [neut fem]]]]
                           [indef plur [nom acc]]])}
   {PUT großen
    lex(cats            : [adj]
        agrs            : [[none  [[masc sing [acc gen]]
                                   [fem  sing gen]
                                   [plur dat]]]
                           [def   [plur dat gen [masc sing acc]]]
                           [indef sing [dat gen [masc acc]]]])}
   {PUT großer
    lex(cats            : [adj]
        agrs            : [[none  [[masc sing nom]
                                   [fem sing [dat gen]]
                                   [plur gen]]]
                           [indef sing masc nom]])}
   {PUT großes
    lex(cats            : [adj]
        agrs            : [[neut sing [nom acc] [indef none]]])}
   {PUT großem
    lex(cats            : [adj]
        agrs            : [[[masc neut] sing dat none]])}
   {PUT ein
    lex(cats            : [vpref])}
   {PUT zu
    lex(cats            : [part])}
   {PUT mit
    lex(cats            : [prep]
        comps_req       : [dative])}
   {PUT heute
    lex(cats            : [adv])}
end


Denys Duchier
Version 1.2.0 (20010221)