merge

Daniel Oklesiński
2 parents 078b7deb 4afde66a
Showing 79 changed files with 3569 additions and 707 deletions
LCGlexicon/ENIAM_LCGlexicon.ml
LCGlexicon/ENIAM_LCGlexiconParser.ml
LCGlexicon/ENIAM_LCGlexiconTypes.ml
LCGlexicon/ENIAM_LCGlexiconTypes_old.ml
LCGlexicon/ENIAM_LCGlexicon_old.ml
LCGlexicon/ENIAMcategoriesPL.ml
LCGlexicon/ENIAMcategoriesPL_old.ml
LCGlexicon/resources/lexicon-pl.dic
LCGlexicon/resources/subst_container.dat
LCGparser/ENIAM_LCG_XMLof.ml
LCGparser/ENIAM_LCGgraphOf.ml
LCGparser/ENIAM_LCGlatexOf.ml
LCGparser/ENIAM_LCGrules.ml
exec/ENIAMexec.ml
exec/ENIAMexecTypes.ml
exec/ENIAMexecXMLof.ml
exec/ENIAMselectSent.ml
exec/ENIAMvisualization.ml
exec/parser.ml
exec/semparser.ml
@@ -165,7 +165,7 @@ let make_rules x_flag filename =
   dict_of_grammar lexicon
  
 let find_rules rules cats =
-  let lex_rules,rules = try StringMap.find rules cats.pos with Not_found -> failwith ("find_rules: unable to find rules for category " ^ cats.pos) in
+  let lex_rules,rules = try StringMap.find rules cats.pos with Not_found -> failwith ("find_rules: unable to find rules for category '" ^ cats.pos ^ "' lemma='" ^ cats.lemma ^ "'") in
   (* Printf.printf "find_rules: %s %s |rules|=%d\n" cats.lemma cats.pos (Xlist.size rules); *)
   let rules = try StringMap.find lex_rules cats.lemma @ rules with Not_found -> rules in
   Xlist.fold rules [] (fun rules (selectors,syntax,semantics) ->
@@ -190,9 +190,12 @@ let assign_valence valence rules =
       if ENIAM_LCGrenderer.count_avar "schema" syntax > 0 then
         Xlist.fold valence l (fun l (selectors,schema) ->
             try
+              (* Printf.printf "selectors: %s\n" (string_of_selectors selectors); *)
+              (* Printf.printf "cats: %s\n%!" (string_of_cats cats); *)
               let cats = apply_selectors cats selectors in
+              (* print_endline "passed"; *)
               (cats,(bracket,quant,ENIAM_LCGrenderer.substitute_schema "schema" schema syntax),semantics) :: l
-            with Not_found -> l)
+            with Not_found -> ((*print_endline "rejected";*) l))
       else (cats,(bracket,quant,syntax),semantics) :: l)
  
 type labels = {
@@ -231,10 +234,13 @@ let make_quantification e rules =
 let make_node id orth lemma pos syntax weight cat_list is_raised =
   let attrs = Xlist.fold cat_list [] (fun attrs -> function
       | Lemma -> attrs
+      | IncludeLemmata -> attrs
       | Pos -> attrs
       | Pos2 -> attrs
       | Cat -> ("CAT",SubstVar "cat") :: attrs
-      | Proj -> ("PROJ",SubstVar "proj") :: attrs
+      | Coerced -> ("COERCED",SubstVar "coerced") :: attrs
+      | Role -> ("ROLE",SubstVar "role") :: attrs
+      | SNode -> ("NODE",SubstVar "node") :: attrs
       | Number -> ("NUM",SubstVar "number") :: attrs
       | Case -> ("CASE",SubstVar "case") :: attrs
       | Gender -> ("GEND",SubstVar "gender") :: attrs
@@ -251,16 +257,24 @@ let make_node id orth lemma pos syntax weight cat_list is_raised =
       | Ctype -> ("CTYPE", SubstVar "ctype") :: attrs
       | Mode -> ("MODE", SubstVar "mode") :: attrs
       | Psem -> ("PSEM", SubstVar "psem") :: attrs
+      | Icat -> attrs
       | Inumber -> attrs
       | Igender -> attrs
       | Iperson -> attrs
       | Nperson -> attrs
+      | Ncat -> attrs
       | Plemma -> attrs
       | Unumber -> attrs
       | Ucase -> attrs
       | Ugender -> attrs
       | Uperson -> attrs
-      | Amode -> attrs) in
+      | Amode -> attrs
+      | Irole -> attrs
+      | Prole -> attrs
+      | Nrole -> attrs
+      | Inode -> attrs
+      | Pnode -> attrs
+      | Nnode -> attrs) in
       (* | s -> (string_of_selector s, Dot) :: attrs) in *)
   (* | "lex" -> ("LEX",Val "+") :: attrs *)
   (* | s -> failwith ("make_node: " ^ (string_of_selector s))) in *)
@@ -312,6 +326,7 @@ let create_entries rules id orth cats valence lex_entries =
       (* variable_name_ref := []; *)
       if cats.pos="interp" && cats.lemma="<clause>" then (BracketSet(Forward),Dot) :: l else
       if cats.pos="interp" && cats.lemma="</clause>" then (BracketSet(Backward),Dot) :: l else
+      if (cats.pos2="noun" ||  cats.pos2="verb" ||  cats.pos2="adj" ||  cats.pos2="adv") && cats.cat="X" && not !default_category_flag && cats.pos <> "aglt" then l else
         let e = get_labels () in
         (* print_endline "create_entries 1"; *)
         let rules = find_rules rules cats in
@@ -95,6 +95,7 @@ let match_relation = function
  
 let rec split_mid i0 rev = function
     [i,s] -> List.rev ((i,s) :: rev)
+  | (i1,s) :: (i2,"|") :: (i3,"|") :: l -> raise (ParseError("split_mid", "duplicated delimeter found", i2))
   | (i1,s) :: (i2,"|") :: l -> split_mid i2 ((i1,s) :: rev) l
   | [] -> raise (ParseError("split_mid", "empty", i0))
   | (i,s) :: l -> raise (ParseError("split_mid", "delimiter not found: " ^ String.concat " " (s :: Xlist.map l snd), i))
@@ -17,7 +17,7 @@
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *)
  
-type categories = {lemma: string; pos: string; pos2: string; cat: string; proj: string list;
+type categories = {lemma: string; pos: string; pos2: string; cat: string; coerced: string list; roles: string list; snode: string list;
                    numbers: string list; cases: string list; genders: string list; persons: string list;
                    grads: string list; praeps: string list; acms: string list;
                    aspects: string list; negations: string list; moods: string list; tenses: string list;
@@ -25,10 +25,12 @@ type categories = {lemma: string; pos: string; pos2: string; cat: string; proj: 
                   }
  
 type selector =
-    Lemma | (*NewLemma |*) Pos | Pos2 | Cat | Proj | Number | Case | Gender | Person | Grad | Praep |
+    Lemma | IncludeLemmata | (*NewLemma |*) Pos | Pos2 | Cat | Coerced | Role | SNode |
+    Number | Case | Gender | Person | Grad | Praep |
     Acm | Aspect | Negation | Mood | Tense | Nsyn | Nsem | Ctype | Mode | Psem |
-    Inumber | Igender | Iperson | Nperson | Plemma |
-    Unumber | Ucase | Ugender | Uperson | Amode
+    Icat | Inumber | Igender | Iperson | Nperson | Ncat | Plemma |
+    Unumber | Ucase | Ugender | Uperson | Amode |
+    Irole | Prole | Nrole | Inode | Pnode | Nnode
  
 module OrderedSelector = struct
   type t = selector
@@ -73,12 +75,14 @@ type selector_relation = Eq | Neq (*| StrictEq*)
  
 *)
  
-let empty_cats = {lemma=""; pos=""; pos2=""; cat="X"; proj=[];
+let empty_cats = {lemma=""; pos=""; pos2=""; cat="X"; coerced=[]; roles=[]; snode=[];
                   numbers=[]; cases=[]; genders=[]; persons=[];
                   grads=[]; praeps=[]; acms=[]; aspects=[]; negations=[]; moods=[]; tenses=[];
                   nsyn=[]; nsem=[]; modes=[]; psem=[];
                  }
  
+let default_category_flag = ref true
+
 let resource_path =
   try Sys.getenv "ENIAM_RESOURCE_PATH"
   with Not_found ->
@@ -94,7 +98,7 @@ let data_path =
 let rules_filename = resource_path ^ "/LCGlexicon/lexicon-pl.dic"
 let user_lexicon_filename = data_path ^ "/lexicon.dic"
 let user_cats_filename = data_path ^ "/senses.tab"
-let user_proj_filename = data_path ^ "/projections.tab"
+let user_coerced_filename = data_path ^ "/coercions.tab"
  
 let subst_uncountable_lexemes_filename = resource_path ^ "/LCGlexicon/subst_uncountable.dat"
 let subst_uncountable_lexemes_filename2 = resource_path ^ "/LCGlexicon/subst_uncountable_stare.dat"
+(*
+ *  ENIAM_LCGlexicon is a library that provides LCG lexicon form Polish
+ *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *
+ *  This library is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *)
+
+type categories = {lemma: string; pos: string; pos2: string; cat: string; coerced: string list;
+                   numbers: string list; cases: string list; genders: string list; persons: string list;
+                   grads: string list; praeps: string list; acms: string list;
+                   aspects: string list; negations: string list; moods: string list; tenses: string list;
+                   nsyn: string list; nsem: string list; modes: string list; psem: string list;
+                  }
+
+type selector =
+    Lemma | (*NewLemma |*) Pos | Pos2 | Cat | Coerced | Number | Case | Gender | Person | Grad | Praep |
+    Acm | Aspect | Negation | Mood | Tense | Nsyn | Nsem | Ctype | Mode | Psem |
+    Icat | Inumber | Igender | Iperson | Nperson | Ncat | Plemma |
+    Unumber | Ucase | Ugender | Uperson | Amode
+
+module OrderedSelector = struct
+  type t = selector
+  let compare = compare
+end
+
+module SelectorMap=Xmap.Make(OrderedSelector)
+module SelectorSet=Xset.Make(OrderedSelector)
+
+type rule =
+    Bracket
+  | Quant of (selector * ENIAM_LCGtypes.internal_grammar_symbol) list
+  | Raised of selector list
+  | Syntax of ENIAM_LCGtypes.grammar_symbol
+  | Sem of string
+
+type rule_sem =
+    BasicSem of selector list
+  | RaisedSem of selector list * selector list
+  | TermSem of selector list * string
+  | QuotSem of selector list
+  | InclusionSem of selector list
+  | ConjSem of selector list
+
+type selector_relation = Eq | Neq (*| StrictEq*)
+
+(* x="s" oznacza, że żeby reguła została użyta token musi mieć "s" jako jedną z wartości atrybutu x, reguła zostanie wykonana dla x z usuniętymi pozostałymi wartościami *)
+(* x!="s" oznacza, że żeby reguła została użyta token musi mieć jako jedną z wartości atrybutu x symbol inny od "s", reguła zostanie wykonana dla x z usuniętą wartością "s" *)
+(* x=="s" oznacza, że żeby reguła została użyta token musi mieć "s" jako jednyną z wartość atrybutu x *)
+
+(* wzajemne zależności między kategoriami (np między case i person w subst) są rozstrzygane w ENIAMcategories *)
+
+(* Basic oznacza że kwantyfikacja i term są generowane zgodnie ze standardowymi regułami:
+   - kwantyfikacja przebiega po wszystkich zdefiniowanych kategoriariach i wartościach wziętych z cats
+   - typ jest zadany bezpośrednio
+   - term tworzy wierzchołek w strukturze zależnościowej etykietowany wszystkimi zdefiniowanymi kategoriami
+
+   Quant oznacza że typ i term są generowane zgodnie ze standardowymi regułami:
+   - kwantyfikacja jest zadana bezpośrednio
+   - typ jest zadany bezpośrednio
+   - term tworzy wierzchołek w strukturze zależnościowej etykietowany wszystkimi zdefiniowanymi kategoriami
+
+*)
+
+let empty_cats = {lemma=""; pos=""; pos2=""; cat="X"; coerced=[];
+                  numbers=[]; cases=[]; genders=[]; persons=[];
+                  grads=[]; praeps=[]; acms=[]; aspects=[]; negations=[]; moods=[]; tenses=[];
+                  nsyn=[]; nsem=[]; modes=[]; psem=[];
+                 }
+
+let default_category_flag = ref true
+
+let resource_path =
+  try Sys.getenv "ENIAM_RESOURCE_PATH"
+  with Not_found ->
+    if Sys.file_exists "/usr/share/eniam" then "/usr/share/eniam" else
+    if Sys.file_exists "/usr/local/share/eniam" then "/usr/local/share/eniam" else
+    if Sys.file_exists "resources" then "resources" else
+    failwith "resource directory does not exists"
+
+let data_path =
+  try Sys.getenv "ENIAM_USER_DATA_PATH"
+  with Not_found -> "data"
+
+let rules_filename = resource_path ^ "/LCGlexicon/lexicon-pl.dic"
+let user_lexicon_filename = data_path ^ "/lexicon.dic"
+let user_cats_filename = data_path ^ "/senses.tab"
+let user_coerced_filename = data_path ^ "/coercions.tab"
+
+let subst_uncountable_lexemes_filename = resource_path ^ "/LCGlexicon/subst_uncountable.dat"
+let subst_uncountable_lexemes_filename2 = resource_path ^ "/LCGlexicon/subst_uncountable_stare.dat"
+let subst_container_lexemes_filename = resource_path ^ "/LCGlexicon/subst_container.dat"
+let subst_numeral_lexemes_filename = resource_path ^ "/LCGlexicon/subst_numeral.dat"
+let subst_time_lexemes_filename = resource_path ^ "/LCGlexicon/subst_time.dat"
+
+let adv_modes_filename = resource_path ^ "/Walenty/adv_modes.tab"
+let num_nsems_filename = resource_path ^ "/LCGlexicon/num.tab"
+(*
+ *  ENIAM_LCGlexicon is a library that provides LCG lexicon form Polish
+ *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *
+ *  This library is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *)
+
+open Xstd
+open ENIAM_LCGtypes
+open ENIAM_LCGlexiconTypes
+open ENIAMcategoriesPL
+
+let rec find_selector s = function
+    (t,Eq,x :: _) :: l -> if t = s then x else find_selector s l
+  | (t,_,_) :: l -> if t = s then failwith "find_selector 1" else find_selector s l
+  | [] -> failwith "find_selector 2"
+
+let rec get_syntax rev = function
+    Syntax syntax :: rule -> syntax, (List.rev rev) @ rule
+  | t :: rule -> get_syntax (t :: rev) rule
+  | [] -> failwith "get_syntax"
+
+let rec get_quant rev = function
+    Quant quant :: rule -> quant, (List.rev rev) @ rule
+  | t :: rule -> get_quant (t :: rev) rule
+  | [] -> [],  List.rev rev
+
+let rec get_bracket rev = function
+    Bracket :: rule -> true, (List.rev rev) @ rule
+  | t :: rule -> get_bracket (t :: rev) rule
+  | [] -> false, List.rev rev
+
+let rec get_raised rev = function
+    Raised raised :: rule -> raised, (List.rev rev) @ rule
+  | t :: rule -> get_raised (t :: rev) rule
+  | [] -> raise Not_found
+
+let rec get_sem_term rev = function
+    Sem sem_term :: rule -> sem_term, (List.rev rev) @ rule
+  | t :: rule -> get_sem_term (t :: rev) rule
+  | [] -> raise Not_found
+
+let merge_quant pos_quants quants =
+  let map = Xlist.fold quants SelectorMap.empty (fun map (k,v) -> SelectorMap.add map k v) in
+  let l,map = Xlist.fold pos_quants ([],map) (fun (l,map) (cat,v) ->
+      if SelectorMap.mem map cat then (cat,SelectorMap.find map cat) :: l, SelectorMap.remove map cat
+      else (cat,v) :: l, map) in
+  List.rev (SelectorMap.fold map l (fun l cat v -> (cat,v) :: l))
+
+let assign_quantifiers (selectors,rule,weight) =
+  let pos = find_selector Pos selectors in
+  let categories =
+    try StringMap.find pos_categories pos
+    with Not_found -> failwith ("assign_quantifiers: unknown part of speech " ^ pos) in
+  let categories = Xlist.map categories (fun s -> s,Top) in
+  let syntax,rule = get_syntax [] rule in
+  let quant,rule = get_quant [] rule in
+  let bracket,rule = get_bracket [] rule in
+  let quant = merge_quant categories quant in
+  selectors, (bracket,quant,syntax),(rule,weight)
+
+let rec check_quantifiers_int_rec (selectors,syntax) quants = function
+    Atom x -> ()
+  | AVar "schema" -> ()
+  | AVar x ->
+     if not (SelectorSet.mem quants (selector_of_string x))
+     then failwith ("Variable '" ^ x ^ "' is not quantified in rule " ^ string_of_selectors selectors ^ ": " ^ ENIAM_LCGstringOf.grammar_symbol 0 syntax)
+  | With l -> Xlist.iter l (check_quantifiers_int_rec (selectors,syntax) quants)
+  | Zero -> ()
+  | Top -> ()
+
+let rec check_quantifiers_rec rule quants  = function
+    Tensor l -> Xlist.iter l (check_quantifiers_int_rec rule quants)
+  | Plus l -> Xlist.iter l (check_quantifiers_rec rule quants)
+  | Imp(s,d,t) -> check_quantifiers_rec rule quants s; check_quantifiers_rec rule quants t
+  | One -> ()
+  | ImpSet(s,l) -> check_quantifiers_rec rule quants s;  Xlist.iter l (fun (_,t) -> check_quantifiers_rec rule quants t)
+  | Star s -> check_quantifiers_rec rule quants s
+  | Maybe s -> check_quantifiers_rec rule quants s
+  | _ -> failwith "check_quantifiers_rec"
+
+let check_quantifiers (selectors,(bracket,quant,syntax),_) =
+  let quants = Xlist.fold quant SelectorSet.empty (fun quants (q,_) -> SelectorSet.add quants q) in
+  check_quantifiers_rec (selectors,syntax) quants syntax
+
+let assign_semantics (selectors,(bracket,quant,syntax),(rule,weight)) =
+  let semantics = try
+    let raised,rule = get_raised [] rule in
+    if rule <> [] then failwith "assign_semantics 1" else
+      RaisedSem(Xlist.map quant fst, raised)
+    with Not_found -> (try
+      let term,rule = get_sem_term [] rule in
+      if rule <> [] then failwith "assign_semantics 2" else
+        TermSem(Xlist.map quant fst,term)
+      with Not_found -> BasicSem(Xlist.map quant fst)) in
+  selectors,(bracket,quant,syntax),(semantics,weight)
+
+let rec add_x_args_rec = function
+    Imp(s,d,t) -> Imp(add_x_args_rec s,d,t)
+  | ImpSet(s,l) -> ImpSet(add_x_args_rec s,l)
+  | Tensor[Atom "<conll_root>"] ->  Tensor[Atom "<conll_root>"]
+  | Tensor l -> ImpSet(Tensor l,[Backward,Maybe(Tensor[Atom "X"]);Forward,Maybe(Tensor[Atom "X"])])
+  | t -> failwith ("add_x_args_rec: " ^ ENIAM_LCGstringOf.grammar_symbol 0 t)
+
+let is_raised_semantics = function
+    RaisedSem _ -> true
+  | _ -> false
+
+let rec is_raised_arg = function
+    Imp _ -> true
+  | Tensor _ -> false
+  | Plus l -> Xlist.fold l false (fun b t -> is_raised_arg t || b)
+  | Maybe t -> is_raised_arg t
+  | One -> false
+  | t -> failwith ("is_raised_arg: " ^ ENIAM_LCGstringOf.grammar_symbol 0 t)
+
+let rec is_raised_syntax = function
+    Imp(s,d,t) -> is_raised_syntax s || is_raised_arg t
+  | ImpSet(s,l) -> is_raised_syntax s || Xlist.fold l false (fun b (_,t) -> is_raised_arg t || b)
+  | Tensor _ -> false
+  | t -> failwith ("is_raised_syntax: " ^ ENIAM_LCGstringOf.grammar_symbol 0 t)
+
+
+let add_x_args (selectors,(bracket,quant,syntax),(semantics,weight)) =
+  if is_raised_syntax syntax then (selectors,(bracket,quant,syntax),(semantics,weight))
+  else (selectors,(bracket,quant,add_x_args_rec syntax),(semantics,weight))
+
+let rec extract_category pat rev = function
+    (cat,rel,v) :: l -> if cat = pat then rel,v,(List.rev rev @ l) else extract_category pat ((cat,rel,v) :: rev) l
+  | [] -> raise Not_found
+
+let dict_of_grammar grammar =
+  (* print_endline "dict_of_grammar"; *)
+  Xlist.fold grammar StringMap.empty (fun dict (selectors,(bracket,quant,syntax),semantics) ->
+      let pos_rel,poss,selectors = try extract_category Pos [] selectors with Not_found -> failwith "dict_of_grammar 1" in
+      let lemma_rel,lemmas,selectors = try extract_category Lemma [] selectors with Not_found -> Eq,[],selectors in
+      if pos_rel <> Eq || lemma_rel <> Eq then failwith "dict_of_grammar 2" else
+        let rule = selectors,(bracket,quant,syntax),semantics in
+        Xlist.fold poss dict (fun dict pos ->
+            let dict2,l = try StringMap.find dict pos with Not_found -> StringMap.empty,[] in
+            let dict2,l =
+              if lemmas = [] then dict2,rule :: l else
+                Xlist.fold lemmas dict2 (fun dict2 lemma ->
+                    StringMap.add_inc dict2 lemma [rule] (fun l -> rule :: l)),l in
+            StringMap.add dict pos (dict2,l)))
+
+let make_rules x_flag filename =
+  let lexicon = ENIAM_LCGlexiconParser.load_lexicon filename in
+  let lexicon = List.rev (Xlist.rev_map lexicon assign_quantifiers) in
+  Xlist.iter lexicon check_quantifiers;
+  let lexicon = List.rev (Xlist.rev_map lexicon assign_semantics) in
+  let lexicon = if x_flag then List.rev (Xlist.rev_map lexicon add_x_args) else lexicon in
+  dict_of_grammar lexicon
+
+let find_rules rules cats =
+  let lex_rules,rules = try StringMap.find rules cats.pos with Not_found -> failwith ("find_rules: unable to find rules for category '" ^ cats.pos ^ "' lemma='" ^ cats.lemma ^ "'") in
+  (* Printf.printf "find_rules: %s %s |rules|=%d\n" cats.lemma cats.pos (Xlist.size rules); *)
+  let rules = try StringMap.find lex_rules cats.lemma @ rules with Not_found -> rules in
+  Xlist.fold rules [] (fun rules (selectors,syntax,semantics) ->
+      try
+        let cats = apply_selectors cats selectors in
+        (cats,syntax,semantics) :: rules
+      with Not_found -> rules)
+
+let prepare_lex_entries rules lex_entries cats =
+  Xlist.fold lex_entries rules (fun rules (selectors,rule) ->
+      let selectors = (Pos,Eq,[cats.pos]) :: selectors in
+      let selectors,(bracket,quant,syntax),(rule,weight) = assign_quantifiers (selectors,[Syntax rule],0.) in
+      let selectors,(bracket,quant,syntax),(semantics,weight) = assign_semantics (selectors,(bracket,quant,syntax),(rule,weight)) in
+      try
+        let cats = apply_selectors cats selectors in
+        (cats,(bracket,quant,syntax),(semantics,weight)) :: rules
+      with Not_found -> rules)
+
+let assign_valence valence rules =
+  Xlist.fold rules [] (fun l (cats,(bracket,quant,syntax),semantics) ->
+      (* Printf.printf "%s %s |valence|=%d\n" cats.lemma cats.pos (Xlist.size valence); *)
+      if ENIAM_LCGrenderer.count_avar "schema" syntax > 0 then
+        Xlist.fold valence l (fun l (selectors,schema) ->
+            try
+              let cats = apply_selectors cats selectors in
+              (cats,(bracket,quant,ENIAM_LCGrenderer.substitute_schema "schema" schema syntax),semantics) :: l
+            with Not_found -> l)
+      else (cats,(bracket,quant,syntax),semantics) :: l)
+
+type labels = {
+  number: string;
+  case: string;
+  gender: string;
+  person: string;
+  aspect: string;
+}
+
+let get_label e = function
+    Number -> e.number
+  | Case -> e.case
+  | Gender -> e.gender
+  | Person -> e.person
+  | Aspect -> e.aspect
+  | _ -> ENIAM_LCGreductions.get_variant_label ()
+
+let get_labels () = {
+  number=ENIAM_LCGreductions.get_variant_label ();
+  case=ENIAM_LCGreductions.get_variant_label ();
+  gender=ENIAM_LCGreductions.get_variant_label ();
+  person=ENIAM_LCGreductions.get_variant_label ();
+  aspect=ENIAM_LCGreductions.get_variant_label ();
+}
+
+let make_quantification e rules =
+  Xlist.map rules (fun (cats,(bracket,quant,syntax),semantics) ->
+      let syntax = Xlist.fold (List.rev quant) syntax (fun syntax (cat,t) ->
+          let t = if t = Top then ENIAM_LCGrenderer.make_quant_restriction (match_selector cats cat) else t in
+          let category = string_of_selector cat in
+          WithVar(category,t,get_label e cat,syntax)) in
+      let syntax = if bracket then ENIAM_LCGtypes.Bracket(true,true,syntax) else ENIAM_LCGtypes.Bracket(false,false,syntax) in
+      cats,syntax,semantics)
+
+let make_node id orth lemma pos syntax weight cat_list is_raised =
+  let attrs = Xlist.fold cat_list [] (fun attrs -> function
+      | Lemma -> attrs
+      | Pos -> attrs
+      | Pos2 -> attrs
+      | Cat -> ("CAT",SubstVar "cat") :: attrs
+      | Coerced -> ("COERCED",SubstVar "coerced") :: attrs
+      | Number -> ("NUM",SubstVar "number") :: attrs
+      | Case -> ("CASE",SubstVar "case") :: attrs
+      | Gender -> ("GEND",SubstVar "gender") :: attrs
+      | Person -> ("PERS",SubstVar "person") :: attrs
+      | Grad -> ("GRAD",SubstVar "grad") :: attrs
+      | Praep -> attrs
+      | Acm -> ("ACM",SubstVar "acm") :: attrs
+      | Aspect -> ("ASPECT", SubstVar "aspect") :: attrs
+      | Negation -> ("NEGATION",SubstVar "negation") :: attrs
+      | Mood -> ("MOOD", SubstVar "mood") :: attrs
+      | Tense -> ("TENSE", SubstVar "tense") :: attrs
+      | Nsyn -> ("NSYN", SubstVar "nsyn") :: attrs
+      | Nsem -> ("NSEM", SubstVar "nsem") :: attrs
+      | Ctype -> ("CTYPE", SubstVar "ctype") :: attrs
+      | Mode -> ("MODE", SubstVar "mode") :: attrs
+      | Psem -> ("PSEM", SubstVar "psem") :: attrs
+      | Icat -> attrs
+      | Inumber -> attrs
+      | Igender -> attrs
+      | Iperson -> attrs
+      | Nperson -> attrs
+      | Ncat -> attrs
+      | Plemma -> attrs
+      | Unumber -> attrs
+      | Ucase -> attrs
+      | Ugender -> attrs
+      | Uperson -> attrs
+      | Amode -> attrs) in
+      (* | s -> (string_of_selector s, Dot) :: attrs) in *)
+  (* | "lex" -> ("LEX",Val "+") :: attrs *)
+  (* | s -> failwith ("make_node: " ^ (string_of_selector s))) in *)
+  let symbol = if is_raised then
+      ENIAM_LCGrenderer.make_raised_symbol syntax
+    else ENIAM_LCGrenderer.make_symbol syntax in
+  {ENIAM_LCGrenderer.empty_node with
+     orth=orth; lemma=lemma; pos=pos; symbol=symbol;
+     weight=weight; id=id; attrs=List.rev attrs; args=Dot}
+
+let or_frame node =
+  (*Imp(Imp(Imp(Tensor[Atom "<root>"],Forward,
+              Tensor[Atom "</speaker>"]),Forward,
+          Imp(Tensor[Atom "ip"; Top; Top; Top],Forward,Tensor[Atom "or"])),Forward,
+      Tensor[Atom "or2"]),*)
+  (* Lambda("x",Lambda("y",Lambda("z",Node{node with gs=make_gs [] ["<root>"]; args=Tuple[
+    Cut(SetAttr("AROLE",Val "Clause",SetAttr("GF",Gf CLAUSE,App(Var "y",Var "x"))))]}))) *)
+  VariantVar("lemma",Lambda("x",Lambda("y",Lambda("z",Node{node with args=Tuple[
+    Cut(SetAttr("ARG_SYMBOL",Tuple[Val "TODO"],App(Var "y",Var "x")))]}))))
+
+let make_term id orth rules =
+  Xlist.map rules (fun (cats,syntax,(semantics,weight)) ->
+      ENIAM_LCGrenderer.reset_variable_names ();
+      ENIAM_LCGrenderer.add_variable_numbers ();
+      (* print_endline ("make_term 0: " ^ ENIAM_LCGstringOf.grammar_symbol 0 syntax); *)
+      match semantics with
+        BasicSem cat_list ->
+        let node = make_node id orth cats.lemma cats.pos syntax weight(*+.token.ENIAMtokenizerTypes.weight*) cat_list false in
+        (* print_endline ("make_term 1: " ^ ENIAM_LCGstringOf.grammar_symbol 0 syntax); *)
+        let semantics = ENIAM_LCGrenderer.make_term node syntax in
+        ENIAM_LCGrenderer.simplify (syntax,semantics)
+      | RaisedSem(cat_list,outer_cat_list) ->
+        (* FIXME: jakie atrybuty powinien mieć outer node (w szczególności jaką wagę?) *)
+        let node = make_node id orth cats.lemma cats.pos syntax weight(*+.token.ENIAMtokenizerTypes.weight*) cat_list true in
+        let outer_node = make_node id orth cats.lemma cats.pos syntax weight(*+.token.ENIAMtokenizerTypes.weight*) outer_cat_list false in
+        (* print_endline ("make_term 2: " ^ ENIAM_LCGstringOf.grammar_symbol 0 syntax); *)
+        let semantics = ENIAM_LCGrenderer.make_raised_term node outer_node syntax in
+        ENIAM_LCGrenderer.simplify (syntax,semantics)
+      | TermSem(cat_list,"λxλyλz.NODE(yx,z)") ->
+        let node = make_node id orth cats.lemma cats.pos syntax weight(*+.token.ENIAMtokenizerTypes.weight*) cat_list false in
+        (* print_endline ("make_term 3: " ^ ENIAM_LCGstringOf.grammar_symbol 0 syntax); *)
+        let semantics = or_frame node in
+        ENIAM_LCGrenderer.simplify (syntax,semantics)
+      | _ -> failwith "make_term: ni")
+
+let create_entries rules id orth cats valence lex_entries =
+  Xlist.fold cats [] (fun l cats ->
+      (* Printf.printf "create_entries: orth=%s lemma=%s pos=%s\n" orth cats.lemma cats.pos; *)
+      (* variable_name_ref := []; *)
+      if cats.pos="interp" && cats.lemma="<clause>" then (BracketSet(Forward),Dot) :: l else
+      if cats.pos="interp" && cats.lemma="</clause>" then (BracketSet(Backward),Dot) :: l else
+      if (cats.pos2="noun" ||  cats.pos2="verb" ||  cats.pos2="adj" ||  cats.pos2="adv") && cats.cat="X" && not !default_category_flag && cats.pos <> "aglt" then l else
+        let e = get_labels () in
+        (* print_endline "create_entries 1"; *)
+        let rules = find_rules rules cats in
+        let rules = prepare_lex_entries rules lex_entries cats in
+        (* Printf.printf "create_entries 2: %s %s |rules|=%d\n" cats.lemma cats.pos (Xlist.size rules); *)
+        let rules = assign_valence valence rules in
+        (* print_endline "create_entries 3"; *)
+        let rules = make_quantification e rules in
+        (* print_endline "create_entries 4"; *)
+        let rules = make_term id orth rules in
+        (* print_endline "create_entries 5"; *)
+        rules @ l)
@@ -29,18 +29,27 @@ let all_persons = [&quot;pri&quot;;&quot;sec&quot;;&quot;ter&quot;]
  
 let selector_values = Xlist.fold [
     Lemma, [];
-    Pos, ["subst";"depr";"ppron12";"ppron3";"siebie";"prep";"num";"intnum";
+    IncludeLemmata, [];
+    Pos, ["subst";"depr";"ppron12";"ppron3";"siebie";"prep";"fixed";"num";"numcomp";"intnum";
           "realnum";"intnum-interval";"realnum-interval";"symbol";"ordnum";
           "date";"date-interval";"hour-minute";"hour";"hour-minute-interval";
           "hour-interval";"year";"year-interval";"day";"day-interval";"day-month";
           "day-month-interval";"month-interval";"roman";"roman-interval";"roman-ordnum";
-          "match-result";"url";"email";"obj-id";"building-number";"adj";"adjc";"adjp";"adja";
+          "match-result";"url";"email";"phone-number";"postal-code";"obj-id";"building-number";"list-item";"adj";"adjc";"adjp";"adja";
           "adv";"ger";"pact";"ppas";"fin";"bedzie";"praet";"winien";"impt";
-          "imps";"pred";"aglt";"inf";"pcon";"pant";"qub";"part";"comp";"conj";"interj";
+          "imps";"pred";"aglt";"inf";"pcon";"pant";"pacta";"qub";"part";"comp";"conj";"interj";
           "sinterj";"burk";"interp";"xxx";"unk";"html-tag";"apron";"compar"];
     Pos2, [];
     Cat, [];
-    Proj, [];
+    Coerced, [];
+    Role, [];
+    Irole, [];
+    Prole, [];
+    Nrole, [];
+    SNode, ["concept";"sit";"dot";"relations"];
+    Inode, ["concept";"sit";"dot";"relations"];
+    Pnode, ["concept";"sit";"dot";"relations"];
+    Nnode, ["concept";"sit";"dot";"relations"];
     Number, all_numbers;
     Case, "postp" :: "pred" :: all_cases;
     Gender, all_genders;
@@ -124,7 +133,7 @@ let noun_type proper lemma pos =
     if pos = "ppron12" || pos = "ppron3" || pos = "siebie" then "pronoun" else
     if pos = "symbol" || pos = "date" || pos = "date-interval" || pos = "hour" || pos = "hour-minute" || pos = "hour-interval" || pos = "hour-minute-interval" ||
        pos = "year" || pos = "year-interval" || pos = "day" || pos = "day-interval" || pos = "day-month" || pos = "day-month-interval" ||
-       pos = "match-result" || pos = "month-interval" || pos = "roman" || pos = "roman-interval" || pos = "url" || pos = "email" || pos = "obj-id" || pos = "building-number" || pos = "date" then "proper" else
+       pos = "match-result" || pos = "month-interval" || pos = "roman" || pos = "roman-interval" || pos = "url" || pos = "email" || pos = "phone-number" || pos = "postal-code" || pos = "obj-id" || pos = "building-number" || pos = "date" then "proper" else
     if StringSet.mem subst_pronoun_lexemes lemma then "pronoun" else
     "common" in
   let nsem =
@@ -150,7 +159,9 @@ let num_nsem lemma =
  
 let part_set = StringSet.of_list ["się"; "nie"; "by"; "niech"; "niechaj"; "niechże"; "niechajże"; "czy"; "gdyby"]
  
-let clarify_categories proper cat proj = function
+let snode = SelectorMap.find selector_values SNode
+
+let clarify_categories proper cat coerced (*snode*) = function
     lemma,"subst",[numbers;cases;genders] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
@@ -158,9 +169,9 @@ let clarify_categories proper cat proj = function
       let cases,voc = split_voc cases in
       let nsyn,nsem = noun_type proper lemma "subst" in
       (if cases = [] then [] else
-         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
       (if voc = [] then [] else
-         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; proj=proj; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
   | lemma,"subst",[numbers;cases;genders;_] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
@@ -168,9 +179,9 @@ let clarify_categories proper cat proj = function
       let cases,voc = split_voc cases in
       let nsyn,nsem = noun_type proper lemma "subst" in
       (if cases = [] then [] else
-         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
       (if voc = [] then [] else
-         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; proj=proj; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
   | lemma,"depr",[numbers;cases;genders] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
@@ -178,29 +189,29 @@ let clarify_categories proper cat proj = function
       let cases,voc = split_voc cases in
       let nsyn,nsem = noun_type proper lemma "depr" in
       (if cases = [] then [] else
-         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
       (if voc = [] then [] else
-         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; proj=proj; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
   | lemma,"ppron12",[numbers;cases;genders;persons] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="ppron12"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons}]
+      [{empty_cats with lemma=lemma; pos="ppron12"; pos2="pron"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=persons}]
   | lemma,"ppron12",[numbers;cases;genders;persons;akcs] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="ppron12"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons}]
+      [{empty_cats with lemma=lemma; pos="ppron12"; pos2="pron"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=persons}]
   | lemma,"ppron3",[numbers;cases;genders;persons] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=["praep-npraep"]}]
+      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=["praep-npraep"]}]
   | lemma,"ppron3",[numbers;cases;genders;persons;akcs] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=["praep-npraep"]}]
+      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=["praep-npraep"]}]
   | lemma,"ppron3",[numbers;cases;genders;persons;akcs;praep] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
@@ -209,207 +220,216 @@ let clarify_categories proper cat proj = function
         ["praep";"npraep"] -> ["praep-npraep"]
       | ["npraep";"praep"] -> ["praep-npraep"]
       | _ -> praep in
-      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=praep}]
+      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=praep}]
   | lemma,"siebie",[cases] -> (* FIXME: czy tu określać numbers genders persons? *)
       let cases = expand_cases cases in
-      [{empty_cats with lemma=lemma; pos="siebie"; pos2="pron"; numbers=all_numbers; cases=cases; genders=all_genders; persons=["ter"]}]
+      [{empty_cats with lemma=lemma; pos="siebie"; pos2="pron"; snode=snode; numbers=all_numbers; cases=cases; genders=all_genders; persons=["ter"]}]
   | lemma,"prep",[cases;woks] ->
       if StringSet.mem compar_lexemes lemma then
         [{empty_cats with lemma=lemma; pos="compar"; pos2="prep"}] else
       let cases = expand_cases cases in
-      [{empty_cats with lemma=lemma; pos="prep"; pos2="prep"; cases=cases; psem=["sem";"nosem"]}]
+      [{empty_cats with lemma=lemma; pos="prep"; pos2="prep"; snode=snode; cases=cases; psem=["sem";"nosem"]}]
   | lemma,"prep",[cases] ->
       if StringSet.mem compar_lexemes lemma then
         [{empty_cats with lemma=lemma; pos="compar"; pos2="prep"}] else
       let cases = expand_cases cases in
-      [{empty_cats with lemma=lemma; pos="prep"; pos2="prep"; cases=cases; psem=["sem";"nosem"]}]
+      [{empty_cats with lemma=lemma; pos="prep"; pos2="prep"; snode=snode; cases=cases; psem=["sem";"nosem"]}]
   | lemma,"num",[numbers;cases;genders;acms] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
       let nsem = num_nsem lemma in
-      [{empty_cats with lemma=lemma; pos="num"; pos2="num"; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; acms=acms; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="num"; pos2="num"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; acms=acms; nsem=nsem}]
   | lemma,"num",[numbers;cases;genders;acms;_] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
       let nsem = num_nsem lemma in
-      [{empty_cats with lemma=lemma; pos="num"; pos2="num"; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; acms=acms; nsem=nsem}]
-  | lemma,"numc",[] -> []
+      [{empty_cats with lemma=lemma; pos="num"; pos2="num"; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; acms=acms; nsem=nsem}]
+  | lemma,"numcomp",[] -> [{empty_cats with lemma=lemma; pos="numcomp"; pos2="numcomp"; snode=snode}]
   | lemma,"intnum",[] ->
       let numbers,acms =
         if lemma = "1" || lemma = "-1" then ["sg"],["congr"] else
         let s = String.get lemma (String.length lemma - 1) in
         ["pl"],if s = '2' || s = '3' || s = '4' then ["rec";"congr"] else ["rec"] in
-      [{empty_cats with lemma=lemma; pos="intnum"; pos2="num"; numbers=numbers; cases=all_cases; genders=all_genders; persons=["ter"]; acms=acms; nsem=["count"]}]
+      [{empty_cats with lemma=lemma; pos="intnum"; pos2="num"; snode=snode; numbers=numbers; cases=all_cases; genders=all_genders; persons=["ter"]; acms=acms; nsem=["count"]}]
   | lemma,"realnum",[] ->
-      [{empty_cats with lemma=lemma; pos="realnum"; pos2="num"; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec"]; nsem=["count"]}]
+      [{empty_cats with lemma=lemma; pos="realnum"; pos2="num"; snode=snode; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec"]; nsem=["count"]}]
   | lemma,"intnum-interval",[] ->
-      [{empty_cats with lemma=lemma; pos="intnum-interval"; pos2="num"; numbers=["pl"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec";"congr"]; nsem=["count"]}]
+      [{empty_cats with lemma=lemma; pos="intnum-interval"; pos2="num"; snode=snode; numbers=["pl"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec";"congr"]; nsem=["count"]}]
   | lemma,"realnum-interval",[] ->
-      [{empty_cats with lemma=lemma; pos="realnum-interval"; pos2="num"; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec"]; nsem=["count"]}]
+      [{empty_cats with lemma=lemma; pos="realnum-interval"; pos2="num"; snode=snode; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec"]; nsem=["count"]}]
   | lemma,"symbol",[] ->
-      [{empty_cats with lemma=lemma; pos="symbol"; pos2="noun"; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]}]
+      [{empty_cats with lemma=lemma; pos="symbol"; pos2="noun"; snode=snode; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]}]
   | lemma,"ordnum",[] ->
-      [{empty_cats with lemma=lemma; pos="ordnum"; pos2="adj"; numbers=all_numbers; cases=all_cases; genders=all_genders; grads=["pos"]}] (* FIXME: czy dać możliwość więcej niż jednego stopnia *)
+      [{empty_cats with lemma=lemma; pos="ordnum"; pos2="adj"; snode=snode; numbers=all_numbers; cases=all_cases; genders=all_genders; grads=["pos"]}] (* FIXME: czy dać możliwość więcej niż jednego stopnia *)
   | lemma,"date",[] ->
       let nsyn,nsem = noun_type proper lemma "date" in
-      [{empty_cats with lemma=lemma; pos="date"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="date"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"date-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "date-interval" in
-      [{empty_cats with lemma=lemma; pos="date-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="date-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"hour-minute",[] ->
       let nsyn,nsem = noun_type proper lemma "hour-minute" in
-      [{empty_cats with lemma=lemma; pos="hour-minute"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="hour-minute"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"hour",[] ->
       let nsyn,nsem = noun_type proper lemma "hour" in
-      [{empty_cats with lemma=lemma; pos="hour"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="hour"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"hour-minute-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "hour-minute-interval" in
-      [{empty_cats with lemma=lemma; pos="hour-minute-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="hour-minute-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"hour-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "hour-interval" in
-      [{empty_cats with lemma=lemma; pos="hour-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="hour-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"year",[] ->
       let nsyn,nsem = noun_type proper lemma "year" in
-      [{empty_cats with lemma=lemma; pos="year"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="year"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"year-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "year-interval" in
-      [{empty_cats with lemma=lemma; pos="year-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="year-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"day",[] ->
       let nsyn,nsem = noun_type proper lemma "day" in
-      [{empty_cats with lemma=lemma; pos="day"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="day"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"day-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "day-interval" in
-      [{empty_cats with lemma=lemma; pos="day-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="day-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"day-month",[] ->
       let nsyn,nsem = noun_type proper lemma "day-month" in
-      [{empty_cats with lemma=lemma; pos="day-month"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="day-month"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"day-month-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "day-month-interval" in
-      [{empty_cats with lemma=lemma; pos="day-month-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="day-month-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"month-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "month-interval" in
-      [{empty_cats with lemma=lemma; pos="month-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="month-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"roman",[] ->
       let nsyn,nsem = noun_type proper lemma "roman" in
-      [{empty_cats with lemma=lemma; pos="roman-ordnum"; pos2="adj"; numbers=all_numbers; cases=all_cases; genders=all_genders; grads=["pos"]};
-       {empty_cats with lemma=lemma; pos="roman"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="roman-ordnum"; pos2="adj"; snode=snode; numbers=all_numbers; cases=all_cases; genders=all_genders; grads=["pos"]};
+       {empty_cats with lemma=lemma; pos="roman"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"roman-interval",[] ->
       let nsyn,nsem = noun_type proper lemma "roman-interval" in
-      [{empty_cats with lemma=lemma; pos="roman-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="roman-interval"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"match-result",[] ->
       let nsyn,nsem = noun_type proper lemma "match-result" in
-      [{empty_cats with lemma=lemma; pos="match-result"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="match-result"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"url",[] ->
       let nsyn,nsem = noun_type proper lemma "url" in
-      [{empty_cats with lemma=lemma; pos="url"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="url"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"email",[] ->
       let nsyn,nsem = noun_type proper lemma "email" in
-      [{empty_cats with lemma=lemma; pos="email"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="email"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
+  | lemma,"phone-number",[] ->
+      let nsyn,nsem = noun_type proper lemma "phone-number" in
+      [{empty_cats with lemma=lemma; pos="phone-number"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
+  | lemma,"postal-code",[] ->
+      let nsyn,nsem = noun_type proper lemma "postal-code" in
+      [{empty_cats with lemma=lemma; pos="postal-code"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"obj-id",[] ->
       let nsyn,nsem = noun_type proper lemma "obj-id" in
-      [{empty_cats with lemma=lemma; pos="obj-id"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="obj-id"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
   | lemma,"building-number",[] ->
       let nsyn,nsem = noun_type proper lemma "building-number" in
-      [{empty_cats with lemma=lemma; pos="building-number"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+      [{empty_cats with lemma=lemma; pos="building-number"; pos2="symbol"; snode=snode; nsyn=nsyn; nsem=nsem}]
+  | lemma,"fixed",[] -> [{empty_cats with lemma=lemma; pos="fixed"; pos2="fixed"; snode=snode}]
   | lemma,"adj",[numbers;cases;genders;grads] -> (* FIXME: adjsyn *)
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
       let genders = expand_genders genders in
       let pos,pos2 = if StringSet.mem adj_pronoun_lexemes lemma then "apron","pron" else "adj","adj" in
-      [{empty_cats with lemma=lemma; pos=pos; pos2=pos2; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; grads=grads}] (* FIXME: czy dać możliwość więcej niż jednego stopnia *)
+      [{empty_cats with lemma=lemma; pos=pos; pos2=pos2; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; grads=grads}] (* FIXME: czy dać możliwość więcej niż jednego stopnia *)
   | lemma,"adjc",[] ->
-      [{empty_cats with lemma=lemma; pos="adjc"; pos2="adj"; cat=cat; proj=proj; numbers=["sg"]; cases=["pred"]; genders=["m1";"m2";"m3"]; grads=["pos"]}]
+      [{empty_cats with lemma=lemma; pos="adjc"; pos2="adj"; cat=cat; coerced=coerced; snode=snode; numbers=["sg"]; cases=["pred"]; genders=["m1";"m2";"m3"]; grads=["pos"]}]
   | lemma,"adjp",[] ->
-      [{empty_cats with lemma=lemma; pos="adjp"; pos2="adj"; cat=cat; proj=proj; numbers=all_numbers; cases=["postp"]; genders=all_genders; grads=["pos"]}]
-  | lemma,"adja",[] -> [{empty_cats with lemma=lemma; cat=cat; proj=proj; pos="adja"; pos2="adja"}]
-  | lemma,"adv",[grads] -> [{empty_cats with lemma=lemma; cat=cat; proj=proj; pos="adv"; pos2="adv"; grads=grads; modes=adv_mode lemma}]
-  | lemma,"adv",[] -> [{empty_cats with lemma=lemma; cat=cat; proj=proj; pos="adv"; pos2="adv"; grads=["pos"]; modes=adv_mode lemma}]
+      [{empty_cats with lemma=lemma; pos="adjp"; pos2="adj"; cat=cat; coerced=coerced; snode=snode; numbers=all_numbers; cases=["postp"]; genders=all_genders; grads=["pos"]}]
+  | lemma,"adja",[] -> [{empty_cats with lemma=lemma; cat=cat; coerced=coerced; snode=snode; pos="adja"; pos2="adja"}]
+  | lemma,"adv",[grads] -> [{empty_cats with lemma=lemma; cat=cat; coerced=coerced; snode=snode; pos="adv"; pos2="adv"; grads=grads; modes=adv_mode lemma}]
+  | lemma,"adv",[] -> [{empty_cats with lemma=lemma; cat=cat; coerced=coerced; snode=snode; pos="adv"; pos2="adv"; grads=["pos"]; modes=adv_mode lemma}]
   | lemma,"ger",[numbers;cases;genders;aspects;negations] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="ger"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; aspects=aspects; negations=negations}] (* FIXME: kwestia osoby przy voc *)
+      [{empty_cats with lemma=lemma; pos="ger"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; aspects=aspects; negations=negations}] (* FIXME: kwestia osoby przy voc *)
   | lemma,"pact",[numbers;cases;genders;aspects;negations] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="pact"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; aspects=aspects; negations=negations}]
+      [{empty_cats with lemma=lemma; pos="pact"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; aspects=aspects; negations=negations}]
   | lemma,"ppas",[numbers;cases;genders;aspects;negations] ->
       let numbers = expand_numbers numbers in
       let cases = expand_cases cases in
       let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="ppas"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; cases=cases; genders=genders; aspects=aspects; negations=negations}]
+      [{empty_cats with lemma=lemma; pos="ppas"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; cases=cases; genders=genders; aspects=aspects; negations=negations}]
   | lemma,"fin",[numbers;persons;aspects] ->  (* FIXME: genders bez przymnogich *)
       let numbers = expand_numbers numbers in
       let persons2 = Xlist.fold persons [] (fun l -> function "sec" -> l | s -> s :: l) in
-      let cats = {empty_cats with lemma=lemma; pos="fin"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=all_genders; persons=persons; negations=["aff"; "neg"]; moods=["indicative"]} in
+      let cats = {empty_cats with lemma=lemma; pos="fin"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=all_genders; persons=persons; negations=["aff"; "neg"]; moods=["indicative"]} in
       (Xlist.map aspects (function
             "imperf" -> {cats with aspects=["imperf"]; tenses=["pres"]}
           | "perf" -> {cats with aspects=["perf"]; tenses=["fut"]}
           | _ -> failwith "clarify_categories")) @
       (if persons2 = [] then [] else
-        [{empty_cats with lemma=lemma; pos="fin"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}])
+        [{empty_cats with lemma=lemma; pos="fin"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}])
   | lemma,"bedzie",[numbers;persons;aspects] ->
       let numbers = expand_numbers numbers in
       let persons2 = Xlist.fold persons [] (fun l -> function "sec" -> l | s -> s :: l) in
-      [{empty_cats with lemma=lemma; pos="bedzie"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}] @
+      [{empty_cats with lemma=lemma; pos="bedzie"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}] @
       (if persons2 = [] then [] else
-        [{empty_cats with lemma=lemma; pos="bedzie"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}])
+        [{empty_cats with lemma=lemma; pos="bedzie"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}])
   | lemma,"praet",[numbers;genders;aspects;nagl] ->
       let numbers = expand_numbers numbers in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["past"]}] @
+      [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["past"]}] @
       (if Xlist.mem aspects "imperf" then
-        [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
+        [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
        else [])
   | lemma,"praet",[numbers;genders;aspects] ->
       let numbers = expand_numbers numbers in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["past"]}] @
+      [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["past"]}] @
       (if Xlist.mem aspects "imperf" then
-        [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
+        [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
        else [])
   | lemma,"winien",[numbers;genders;aspects] ->
       let numbers = expand_numbers numbers in
       let genders = expand_genders genders in
-      [{empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["pres"]};
-       {empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["past"]}] @
+      [{empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["pres"]};
+       {empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["past"]}] @
       (if Xlist.mem aspects "imperf" then
-        [{empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
+        [{empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
        else [])
   | lemma,"impt",[numbers;persons;aspects] ->
       let numbers = expand_numbers numbers in
-      [{empty_cats with lemma=lemma; pos="impt"; pos2="verb"; cat=cat; proj=proj; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}]
+      [{empty_cats with lemma=lemma; pos="impt"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}]
   | lemma,"imps",[aspects] ->
-      [{empty_cats with lemma=lemma; pos="imps"; pos2="verb"; cat=cat; proj=proj; numbers=all_numbers; genders=all_genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["past"]}]
+      [{empty_cats with lemma=lemma; pos="imps"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=all_numbers; genders=all_genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["past"]}]
   | lemma,"pred",[] -> (* FIXME: czy predykatyw zawsze jest niedokonany? *)
-      [{empty_cats with lemma=lemma; pos="pred"; pos2="verb"; cat=cat; proj=proj; numbers=["sg"]; genders=[(*"n2"*)"n"]; persons=["ter"]; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["pres";"past";"fut"]}]
+      [{empty_cats with lemma=lemma; pos="pred"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; numbers=["sg"]; genders=[(*"n2"*)"n"]; persons=["ter"]; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["pres";"past";"fut"]}]
   | lemma,"aglt",[numbers;persons;aspects;wok] ->
       let numbers = expand_numbers numbers in
-      [{empty_cats with lemma=lemma; pos="aglt"; pos2="verb"; numbers=numbers; persons=persons; aspects=aspects}]
-  | lemma,"inf",[aspects] -> [{empty_cats with lemma=lemma; pos="inf"; pos2="verb"; cat=cat; proj=proj; aspects=aspects; negations=["aff"; "neg"]}]
-  | lemma,"pcon",[aspects] -> [{empty_cats with lemma=lemma; pos="pcon"; pos2="verb"; cat=cat; proj=proj; aspects=aspects; negations=["aff"; "neg"]}]
-  | lemma,"pant",[aspects] -> [{empty_cats with lemma=lemma; pos="pant"; pos2="verb"; cat=cat; proj=proj; aspects=aspects; negations=["aff"; "neg"]}]
+      [{empty_cats with lemma=lemma; pos="aglt"; pos2="verb"; snode=snode; numbers=numbers; persons=persons; aspects=aspects}]
+  | lemma,"inf",[aspects] -> [{empty_cats with lemma=lemma; pos="inf"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"pcon",[aspects] -> [{empty_cats with lemma=lemma; pos="pcon"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"pant",[aspects] -> [{empty_cats with lemma=lemma; pos="pant"; pos2="verb"; cat=cat; coerced=coerced; snode=snode; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"pacta",[] -> [{empty_cats with lemma=lemma; pos="pacta"; pos2="verb"; cat=cat; coerced=coerced; snode=snode}]
   | lemma,"qub",[] ->
-      if StringSet.mem part_set lemma then [{empty_cats with lemma=lemma; pos="part"; pos2="qub"}]
-      else [{empty_cats with lemma=lemma; pos="qub"; pos2="qub"}]
-  | lemma,"comp",[] -> [{empty_cats with lemma=lemma; pos="comp"; pos2="comp"}]
-  | lemma,"conj",[] -> [{empty_cats with lemma=lemma; pos="conj"; pos2="conj"}]
-  | lemma,"interj",[] -> [{empty_cats with lemma=lemma; pos="interj"; pos2="interj"}]
-  | lemma,"sinterj",[] -> [{empty_cats with lemma=lemma; pos="sinterj"; pos2="sinterj"}]
-  | lemma,"burk",[] -> [{empty_cats with lemma=lemma; pos="burk"; pos2="burk"}]
-  | ",","interp",[] -> [{empty_cats with lemma=","; pos="conj"; pos2="conj"}]
-  | lemma,"interp",[] -> [{empty_cats with lemma=lemma; pos="interp"; pos2="interp"}]
+      if StringSet.mem part_set lemma then [{empty_cats with lemma=lemma; pos="part"; pos2="qub"; snode=snode}]
+      else [{empty_cats with lemma=lemma; pos="qub"; pos2="qub"; cat=cat; snode=snode}]
+  | lemma,"comp",[] -> [{empty_cats with lemma=lemma; pos="comp"; pos2="comp"; snode=snode}]
+  | lemma,"conj",[] -> [{empty_cats with lemma=lemma; pos="conj"; pos2="conj"; snode=snode}]
+  | lemma,"interj",[] -> [{empty_cats with lemma=lemma; pos="interj"; pos2="interj"; cat=cat; coerced=coerced; snode=snode}]
+  | lemma,"sinterj",[] -> [{empty_cats with lemma=lemma; pos="sinterj"; pos2="sinterj"; (*cat=cat; coerced=coerced;*) snode=snode}]
+  | lemma,"burk",[] -> [{empty_cats with lemma=lemma; pos="burk"; pos2="burk"; snode=snode}]
+  | ",","interp",[] -> [{empty_cats with lemma=","; pos="conj"; pos2="conj"; snode=snode}]
+  | lemma,"interp",[] -> [{empty_cats with lemma=lemma; pos="interp"; pos2="interp"; snode=snode}]
   | lemma,"unk",[] ->
-      [{empty_cats with lemma=lemma; pos="unk"; pos2="noun"; numbers=all_numbers; cases=all_cases; genders=all_genders; persons=["ter"]}]
+      [{empty_cats with lemma=lemma; pos="unk"; pos2="noun"; snode=snode; numbers=all_numbers; cases=all_cases; genders=all_genders; persons=["ter"]}]
   | lemma,"xxx",[] ->
-      [{empty_cats with lemma=lemma; pos="xxx"; pos2="noun"; numbers=all_numbers; cases=all_cases; genders=all_genders; persons=["ter"]}]
-  | lemma,"html-tag",[] -> [{empty_cats with lemma=lemma; pos="html-tag"; pos2="html-tag"}]
+      [{empty_cats with lemma=lemma; pos="xxx"; pos2="noun"; snode=snode; numbers=all_numbers; cases=all_cases; genders=all_genders; persons=["ter"]}]
+  | lemma,"html-tag",[] -> [{empty_cats with lemma=lemma; pos="html-tag"; pos2="html-tag"; snode=snode}]
+  | lemma,"list-item",[] -> [{empty_cats with lemma=lemma; pos="list-item"; pos2="list-item"; snode=snode}]
   | lemma,c,l -> failwith ("clarify_categories: " ^ lemma ^ ":" ^ c ^ ":" ^ (String.concat ":" (Xlist.map l (String.concat "."))))
  
 (* FIXME: przenieść gdzieś indziej *)
@@ -421,19 +441,28 @@ let clarify_categories proper cat proj = function
   | _ -> [] *)
  
 let selector_names = StringSet.of_list [
-    "lemma";"pos";"pos2";"cat";"proj";"number";"case";"gender";"person";"grad";
+    "lemma";"pos";"pos2";"cat";"coerced";"role";"irole";"prole";"nrole";"node";"inode";"pnode";"nnode";"number";"case";"gender";"person";"grad";
     "praep";"acm";"aspect";"negation";"mood";"tense";"nsyn";"nsem";"ctype";"mode";"psem";
-    "inumber";"igender";"iperson";"nperson";"plemma";
+    "icat";"inumber";"igender";"iperson";"nperson";"ncat";"plemma";
     "unumber";"ucase";"ugender";"uperson";"amode"]
  
  
 let string_of_selector = function
     Lemma -> "lemma"
+  | IncludeLemmata -> "include-lemmata"
   (* | NewLemma -> "newlemma" *)
   | Pos -> "pos"
   | Pos2 -> "pos2"
   | Cat -> "cat"
-  | Proj -> "proj"
+  | Coerced -> "coerced"
+  | Role -> "role"
+  | Irole -> "irole"
+  | Prole -> "prole"
+  | Nrole -> "nrole"
+  | SNode -> "node"
+  | Inode -> "inode"
+  | Pnode -> "pnode"
+  | Nnode -> "nnode"
   | Number -> "number"
   | Case -> "case"
   | Gender -> "gender"
@@ -450,10 +479,12 @@ let string_of_selector = function
   | Ctype -> "ctype"
   | Mode -> "mode"
   | Psem -> "psem"
+  | Icat -> "icat"
   | Inumber -> "inumber"
   | Igender -> "igender"
   | Iperson -> "iperson"
   | Nperson -> "nperson"
+  | Ncat -> "ncat"
   | Plemma -> "plemma"
   | Unumber -> "unumber"
   | Ucase -> "ucase"
@@ -468,11 +499,20 @@ let string_of_selectors selectors =
  
 let selector_of_string = function
     "lemma" -> Lemma
+  | "include-lemmata" -> IncludeLemmata
   (* | NewLemma -> "newlemma" *)
   | "pos" -> Pos
   | "pos2" -> Pos2
   | "cat" -> Cat
-  | "proj" -> Proj
+  | "coerced" -> Coerced
+  | "role" -> Role
+  | "irole" -> Irole
+  | "prole" -> Prole
+  | "nrole" -> Nrole
+  | "node" -> SNode
+  | "inode" -> Inode
+  | "pnode" -> Pnode
+  | "nnode" -> Nnode
   | "number" -> Number
   | "case" -> Case
   | "gender" -> Gender
@@ -489,10 +529,12 @@ let selector_of_string = function
   | "ctype" -> Ctype
   | "mode" -> Mode
   | "psem" -> Psem
+  | "icat" -> Icat
   | "inumber" -> Inumber
   | "igender" -> Igender
   | "iperson" -> Iperson
   | "nperson" -> Nperson
+  | "ncat" -> Ncat
   | "plemma" -> Plemma
   | "unumber" -> Unumber
   | "ucase" -> Ucase
@@ -506,7 +548,9 @@ let match_selector cats = function
 (* | NewLemma -> [] *)
   | Pos -> [cats.pos]
   | Cat -> [cats.cat]
-  | Proj -> cats.proj
+  | Coerced -> cats.coerced
+  | Role -> cats.roles
+  | SNode -> cats.snode
   | Number -> cats.numbers
   | Case -> cats.cases
   | Gender -> cats.genders
@@ -543,7 +587,9 @@ let set_selector cats vals = function
   | Lemma -> (match vals with [v] -> {cats with lemma=v} | _ -> failwith "set_selector: Lemma")
   | Pos -> (match vals with [v] -> {cats with pos=v} | _ -> failwith "set_selector: Pos")
   | Cat -> (match vals with [v] -> {cats with cat=v} | _ -> failwith "set_selector: Cat")
-  | Proj -> {cats with proj=vals}
+  | Coerced -> {cats with coerced=vals}
+  | Role -> {cats with roles=vals}
+  | SNode -> {cats with snode=vals}
   | c -> failwith ("set_selector: " ^ string_of_selector c)
  
 let rec apply_selectors cats = function
@@ -558,70 +604,84 @@ let rec apply_selectors cats = function
       apply_selectors (set_selector cats (StringSet.to_list vals) sel) l
  
 let pos_categories = Xlist.fold [
-    "subst",[Lemma;Cat;Proj;Number;Case;Gender;Person;Nsyn;Nsem;];
-    "depr",[Lemma;Cat;Proj;Number;Case;Gender;Person;Nsyn;Nsem;];
-    "ppron12",[Lemma;Number;Case;Gender;Person;];
-    "ppron3",[Lemma;Number;Case;Gender;Person;Praep;];
-    "siebie",[Lemma;Number;Case;Gender;Person;];
-    "prep",[Lemma;Cat;Proj;Psem;Case;];
-    "compar",[Lemma;Cat;Proj;Case;];
-    "num",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
-    "intnum",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
-    "realnum",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
-    "intnum-interval",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
-    "realnum-interval",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
-    "symbol",[Lemma;Number;Case;Gender;Person;];
-    "ordnum",[Lemma;Number;Case;Gender;Grad;];
-    "date",[Lemma;Nsyn;Nsem;];
-    "date-interval",[Lemma;Nsyn;Nsem;];
-    "hour-minute",[Lemma;Nsyn;Nsem;];
-    "hour",[Lemma;Nsyn;Nsem;];
-    "hour-minute-interval",[Lemma;Nsyn;Nsem;];
-    "hour-interval",[Lemma;Nsyn;Nsem;];
-    "year",[Lemma;Nsyn;Nsem;];
-    "year-interval",[Lemma;Nsyn;Nsem;];
-    "day",[Lemma;Nsyn;Nsem;];
-    "day-interval",[Lemma;Nsyn;Nsem;];
-    "day-month",[Lemma;Nsyn;Nsem;];
-    "day-month-interval",[Lemma;Nsyn;Nsem;];
-    "month-interval",[Lemma;Nsyn;Nsem;];
-    "roman-ordnum",[Lemma;Number;Case;Gender;Grad;];
-    "roman",[Lemma;Nsyn;Nsem;];
-    "roman-interval",[Lemma;Nsyn;Nsem;];
-    "match-result",[Lemma;Nsyn;Nsem;];
-    "url",[Lemma;Nsyn;Nsem;];
-    "email",[Lemma;Nsyn;Nsem;];
-    "obj-id",[Lemma;Nsyn;Nsem;];
-    "building-number",[Lemma;Nsyn;Nsem;];
-    "adj",[Lemma;Cat;Proj;Number;Case;Gender;Grad;];
-    "adjc",[Lemma;Cat;Proj;Number;Case;Gender;Grad;];
-    "adjp",[Lemma;Cat;Proj;Number;Case;Gender;Grad;];
-    "apron",[Lemma;Number;Case;Gender;Grad;];
-    "adja",[Lemma;Cat;Proj;];
-    "adv",[Lemma;Cat;Proj;Grad;Mode];(* ctype *)
-    "ger",[Lemma;(*NewLemma;*)Cat;Proj;Number;Case;Gender;Person;Aspect;Negation;];
-    "pact",[Lemma;(*NewLemma;*)Cat;Proj;Number;Case;Gender;Aspect;Negation;];
-    "ppas",[Lemma;(*NewLemma;*)Cat;Proj;Number;Case;Gender;Aspect;Negation;];
-    "fin",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "bedzie",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "praet",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "winien",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "impt",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "imps",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "pred",[Lemma;(*NewLemma;*)Cat;Proj;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
-    "aglt",[Lemma;Number;Person;Aspect;];
-    "inf",[Lemma;(*NewLemma;*)Cat;Proj;Aspect;Negation;];
-    "pcon",[Lemma;(*NewLemma;*)Cat;Proj;Aspect;Negation;];
-    "pant",[Lemma;(*NewLemma;*)Cat;Proj;Aspect;Negation;];
-    "qub",[Lemma;];
-    "part",[Lemma;];
-    "comp",[Lemma;];(* ctype *)
-    "conj",[Lemma;];(* ctype *)
-    "interj",[Lemma;];
-    "sinterj",[Lemma;];
-    "burk",[Lemma;];
-    "interp",[Lemma;];
-    "unk",[Lemma;Number;Case;Gender;Person;];
-    "xxx",[Lemma;Number;Case;Gender;Person;];
-    "html-tag",[Lemma;];
+    "subst",[Lemma;Cat;Coerced;Role;SNode;Number;Case;Gender;Person;Nsyn;Nsem;];
+    "depr",[Lemma;Cat;Coerced;Role;SNode;Number;Case;Gender;Person;Nsyn;Nsem;];
+    "ppron12",[Lemma;SNode;Number;Case;Gender;Person;];
+    "ppron3",[Lemma;SNode;Number;Case;Gender;Person;Praep;];
+    "siebie",[Lemma;SNode;Number;Case;Gender;Person;];
+    "prep",[Lemma;Cat;Coerced;Role;SNode;Psem;Case;];
+    "compar",[Lemma;Cat;Coerced;Role;SNode;Case;];
+    "num",[Lemma;SNode;Number;Case;Gender;Person;Acm;Nsem;];
+    "numcomp",[Lemma;SNode];
+    "intnum",[Lemma;SNode;Number;Case;Gender;Person;Acm;Nsem;];
+    "realnum",[Lemma;SNode;Number;Case;Gender;Person;Acm;Nsem;];
+    "intnum-interval",[Lemma;SNode;Number;Case;Gender;Person;Acm;Nsem;];
+    "realnum-interval",[Lemma;SNode;Number;Case;Gender;Person;Acm;Nsem;];
+    "symbol",[Lemma;SNode;Number;Case;Gender;Person;];
+    "ordnum",[Lemma;SNode;Number;Case;Gender;Grad;];
+    "date",[Lemma;SNode;Nsyn;Nsem;];
+    "date-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "hour-minute",[Lemma;SNode;Nsyn;Nsem;];
+    "hour",[Lemma;SNode;Nsyn;Nsem;];
+    "hour-minute-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "hour-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "year",[Lemma;SNode;Nsyn;Nsem;];
+    "year-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "day",[Lemma;SNode;Nsyn;Nsem;];
+    "day-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "day-month",[Lemma;SNode;Nsyn;Nsem;];
+    "day-month-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "month-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "roman-ordnum",[Lemma;SNode;Number;Case;Gender;Grad;];
+    "roman",[Lemma;SNode;Nsyn;Nsem;];
+    "roman-interval",[Lemma;SNode;Nsyn;Nsem;];
+    "match-result",[Lemma;SNode;Nsyn;Nsem;];
+    "url",[Lemma;SNode;Nsyn;Nsem;];
+    "email",[Lemma;SNode;Nsyn;Nsem;];
+    "phone-number",[Lemma;SNode;Nsyn;Nsem;];
+    "postal-code",[Lemma;SNode;Nsyn;Nsem;];
+    "obj-id",[Lemma;SNode;Nsyn;Nsem;];
+    "building-number",[Lemma;SNode;Nsyn;Nsem;];
+    "fixed",[Lemma;SNode;];
+    "adj",[Lemma;Cat;Coerced;Role;SNode;Number;Case;Gender;Grad;];
+    "adjc",[Lemma;Cat;Coerced;Role;SNode;Number;Case;Gender;Grad;];
+    "adjp",[Lemma;Cat;Coerced;Role;SNode;Number;Case;Gender;Grad;];
+    "apron",[Lemma;Cat;Role;SNode;Number;Case;Gender;Grad;];
+    "adja",[Lemma;Cat;Coerced;Role;SNode;];
+    "adv",[Lemma;Cat;Coerced;Role;SNode;Grad;Mode];(* ctype *)
+    "ger",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Case;Gender;Person;Aspect;Negation;];
+    "pact",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Case;Gender;Aspect;Negation;];
+    "ppas",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Case;Gender;Aspect;Negation;];
+    "fin",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "bedzie",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "praet",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "winien",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "impt",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "imps",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "pred",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "aglt",[Lemma;SNode;Number;Person;Aspect;];
+    "inf",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Aspect;Negation;];
+    "pcon",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Aspect;Negation;];
+    "pant",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;Aspect;Negation;];
+    "pacta",[Lemma;(*NewLemma;*)Cat;Coerced;Role;SNode;];
+    "qub",[Lemma;Cat;Role;SNode;];
+    "part",[Lemma;SNode];
+    "comp",[Lemma;SNode;];(* ctype *)
+    "conj",[Lemma;SNode;];(* ctype *)
+    "interj",[Lemma;Cat;Coerced;Role;SNode;];
+    "sinterj",[Lemma;Cat;Coerced;Role;SNode;];
+    "burk",[Lemma;SNode;];
+    "interp",[Lemma;SNode;];
+    "unk",[Lemma;SNode;Number;Case;Gender;Person;];
+    "xxx",[Lemma;SNode;Number;Case;Gender;Person;];
+    "html-tag",[Lemma;SNode;];
+    "list-item",[Lemma;SNode;];
   ] StringMap.empty (fun map (k,l) -> StringMap.add map k l)
+
+let string_of_cats cats =
+  String.concat ", " (SelectorMap.fold selector_values [] (fun l sel _ ->
+    try
+      let s = String.concat "|" (match_selector cats sel) in
+      if s = "" then l else
+      (string_of_selector sel ^ "=" ^ s) :: l
+    with _ -> l))
+(*
+ *  ENIAM_LCGlexicon is a library that provides LCG lexicon form Polish
+ *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *
+ *  This library is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *)
+
+open ENIAM_LCGlexiconTypes
+open Xstd
+
+let all_numbers = ["sg";"pl"]
+let all_cases = ["nom";"gen";"dat";"acc";"inst";"loc";"voc"]
+(* let all_genders = ["m1";"m2";"m3";"f";"n1";"n2";"p1";"p2";"p3"] *)
+let all_genders = ["m1";"m2";"m3";"f";"n"]
+let all_persons = ["pri";"sec";"ter"]
+(* FIXME: zamiast wszystkich możliwych wartości można używać Zero gdy nie ma uzgodnienia *)
+
+let selector_values = Xlist.fold [
+    Lemma, [];
+    Pos, ["subst";"depr";"ppron12";"ppron3";"siebie";"prep";"fixed";"num";"numcomp";"intnum";
+          "realnum";"intnum-interval";"realnum-interval";"symbol";"ordnum";
+          "date";"date-interval";"hour-minute";"hour";"hour-minute-interval";
+          "hour-interval";"year";"year-interval";"day";"day-interval";"day-month";
+          "day-month-interval";"month-interval";"roman";"roman-interval";"roman-ordnum";
+          "match-result";"url";"email";"phone-number";"postal-code";"obj-id";"building-number";"list-item";"adj";"adjc";"adjp";"adja";
+          "adv";"ger";"pact";"ppas";"fin";"bedzie";"praet";"winien";"impt";
+          "imps";"pred";"aglt";"inf";"pcon";"pant";"qub";"part";"comp";"conj";"interj";
+          "sinterj";"burk";"interp";"xxx";"unk";"html-tag";"apron";"compar"];
+    Pos2, [];
+    Cat, [];
+    Coerced, [];
+    Number, all_numbers;
+    Case, "postp" :: "pred" :: all_cases;
+    Gender, all_genders;
+    Person, all_persons;
+    Grad, ["pos";"com";"sup"];
+    Praep, ["praep";"npraep";"praep-npraep"];
+    Acm, ["congr";"rec"];
+    Ctype, ["int";"rel";"sub";"coord"];
+    Mode, ["abl";"adl";"locat";"perl";"dur";"temp";"mod"];
+    Aspect, ["perf";"imperf"];
+    Negation, ["neg";"aff"];
+    Mood, ["indicative";"imperative";"conditional"];
+    Tense, ["past";"pres";"fut"];
+    Nsyn, ["proper";"pronoun";"common"];
+    Nsem, ["count";"time";"mass";"measure"];
+    Psem, ["sem";"nosem"];
+    Ucase, all_cases;
+] SelectorMap.empty (fun map (selector,vals) -> SelectorMap.add map selector vals)
+
+
+let expand_numbers numbers =
+  if Xlist.mem numbers "_" then all_numbers else numbers
+
+let expand_genders genders  =
+  if Xlist.mem genders "_" then all_genders else genders
+
+let expand_cases cases  =
+  if Xlist.mem cases "_" || Xlist.mem cases "$C" then all_cases else cases
+
+let expand_akcs akcs  =
+  if Xlist.mem akcs "_" then ["akc";"nakc"] else akcs
+
+let split_voc cases =
+  Xlist.fold cases ([],[]) (fun (cases,voc) -> function
+        "voc" -> cases, "voc" :: voc
+      | s -> s :: cases, voc)
+
+let load_subst_data filename _ =
+  StringSet.of_list (File.load_lines filename)
+
+let subst_uncountable_lexemes = ref StringSet.empty
+let subst_uncountable_lexemes2 = ref StringSet.empty
+let subst_container_lexemes = ref StringSet.empty
+let subst_numeral_lexemes = ref StringSet.empty
+let subst_time_lexemes = ref StringSet.empty
+
+let subst_pronoun_lexemes = StringSet.of_list ["co"; "kto"; "cokolwiek"; "ktokolwiek"; "nic"; "nikt"; "coś"; "ktoś"; "to"]
+let adj_pronoun_lexemes = StringSet.of_list ["czyj"; "jaki"; "który"; "jakiś"; "ten"; "taki"]
+let compar_lexemes = StringSet.of_list ["jak"; "jako"; "niż"; "niczym"; "niby"; "co"; "zamiast"]
+
+(* let adj_quant_lexemes = StringSet.of_list ["każdy"; "wszelki"; "wszystek"; "żaden"; "jakiś"; "pewien"; "niektóry"; "jedyny"; "sam"] *)
+
+let load_adv_modes filename adv_modes =
+  File.fold_tab filename adv_modes (fun adv_modes -> function
+      [adv;mode] -> StringMap.add_inc adv_modes adv [mode] (fun l -> mode :: l)
+    | _ -> failwith "load_adv_modes")
+
+let load_num_nsems filename num_nsems =
+  File.fold_tab filename num_nsems (fun num_nsems -> function
+      lemma :: _ :: nsems :: _ ->
+        Xlist.fold (Xstring.split "," nsems) num_nsems (fun num_nsems nsem ->
+          StringMap.add_inc num_nsems lemma [nsem] (fun l -> nsem :: l))
+    | _ -> failwith "load_num_nsems")
+
+let adv_modes = ref (StringMap.empty : string list StringMap.t)
+let num_nsems = ref (StringMap.empty : string list StringMap.t)
+
+let initialize () =
+  subst_uncountable_lexemes := File.catch_no_file (load_subst_data subst_uncountable_lexemes_filename) StringSet.empty;
+  subst_uncountable_lexemes2 := File.catch_no_file (load_subst_data subst_uncountable_lexemes_filename2) StringSet.empty;
+  subst_container_lexemes := File.catch_no_file (load_subst_data subst_container_lexemes_filename) StringSet.empty;
+  subst_numeral_lexemes := File.catch_no_file (load_subst_data subst_numeral_lexemes_filename) StringSet.empty;
+  subst_time_lexemes := File.catch_no_file (load_subst_data subst_time_lexemes_filename) StringSet.empty;
+  adv_modes := File.catch_no_file (load_adv_modes adv_modes_filename) StringMap.empty;
+  num_nsems := File.catch_no_file (load_num_nsems num_nsems_filename) StringMap.empty;
+  ()
+
+let noun_type proper lemma pos =
+  let nsyn =
+    if proper then "proper" else
+    if pos = "ppron12" || pos = "ppron3" || pos = "siebie" then "pronoun" else
+    if pos = "symbol" || pos = "date" || pos = "date-interval" || pos = "hour" || pos = "hour-minute" || pos = "hour-interval" || pos = "hour-minute-interval" ||
+       pos = "year" || pos = "year-interval" || pos = "day" || pos = "day-interval" || pos = "day-month" || pos = "day-month-interval" ||
+       pos = "match-result" || pos = "month-interval" || pos = "roman" || pos = "roman-interval" || pos = "url" || pos = "email" || pos = "phone-number" || pos = "postal-code" || pos = "obj-id" || pos = "building-number" || pos = "date" then "proper" else
+    if StringSet.mem subst_pronoun_lexemes lemma then "pronoun" else
+    "common" in
+  let nsem =
+    if pos = "ppron12" || pos = "ppron3" || pos = "siebie" then ["count"] else
+    if StringSet.mem !subst_time_lexemes lemma then ["time"] else
+    let l = ["count"] in
+    let l = if StringSet.mem !subst_uncountable_lexemes lemma || StringSet.mem !subst_uncountable_lexemes2 lemma then "mass" :: l else l in
+    if StringSet.mem !subst_container_lexemes lemma then "measure" :: l else l in
+  [nsyn],nsem
+
+let adv_mode lemma =
+  try
+    StringMap.find !adv_modes lemma
+  with Not_found -> ["mod"]
+
+let num_nsem lemma =
+  try
+    StringMap.find !num_nsems lemma
+  with Not_found -> (*try
+    StringMap.find !num_nsems (String.lowercase lemma)
+  with Not_found ->*) failwith ("num_nsem: " ^ lemma)
+
+
+let part_set = StringSet.of_list ["się"; "nie"; "by"; "niech"; "niechaj"; "niechże"; "niechajże"; "czy"; "gdyby"]
+
+let clarify_categories proper cat coerced = function
+    lemma,"subst",[numbers;cases;genders] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      let cases,voc = split_voc cases in
+      let nsyn,nsem = noun_type proper lemma "subst" in
+      (if cases = [] then [] else
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
+      (if voc = [] then [] else
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
+  | lemma,"subst",[numbers;cases;genders;_] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      let cases,voc = split_voc cases in
+      let nsyn,nsem = noun_type proper lemma "subst" in
+      (if cases = [] then [] else
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
+      (if voc = [] then [] else
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
+  | lemma,"depr",[numbers;cases;genders] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      let cases,voc = split_voc cases in
+      let nsyn,nsem = noun_type proper lemma "depr" in
+      (if cases = [] then [] else
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; nsyn=nsyn; nsem=nsem}]) @
+      (if voc = [] then [] else
+         [{empty_cats with lemma=lemma; pos="subst"; pos2="noun"; cat=cat; coerced=coerced; numbers=numbers; cases=voc; genders=genders; persons=["sec"]; nsyn=nsyn; nsem=nsem}])
+  | lemma,"ppron12",[numbers;cases;genders;persons] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="ppron12"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons}]
+  | lemma,"ppron12",[numbers;cases;genders;persons;akcs] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="ppron12"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons}]
+  | lemma,"ppron3",[numbers;cases;genders;persons] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=["praep-npraep"]}]
+  | lemma,"ppron3",[numbers;cases;genders;persons;akcs] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=["praep-npraep"]}]
+  | lemma,"ppron3",[numbers;cases;genders;persons;akcs;praep] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      let praep = match praep with
+        ["praep";"npraep"] -> ["praep-npraep"]
+      | ["npraep";"praep"] -> ["praep-npraep"]
+      | _ -> praep in
+      [{empty_cats with lemma=lemma; pos="ppron3"; pos2="pron"; numbers=numbers; cases=cases; genders=genders; persons=persons; praeps=praep}]
+  | lemma,"siebie",[cases] -> (* FIXME: czy tu określać numbers genders persons? *)
+      let cases = expand_cases cases in
+      [{empty_cats with lemma=lemma; pos="siebie"; pos2="pron"; numbers=all_numbers; cases=cases; genders=all_genders; persons=["ter"]}]
+  | lemma,"prep",[cases;woks] ->
+      if StringSet.mem compar_lexemes lemma then
+        [{empty_cats with lemma=lemma; pos="compar"; pos2="prep"}] else
+      let cases = expand_cases cases in
+      [{empty_cats with lemma=lemma; pos="prep"; pos2="prep"; cases=cases; psem=["sem";"nosem"]}]
+  | lemma,"prep",[cases] ->
+      if StringSet.mem compar_lexemes lemma then
+        [{empty_cats with lemma=lemma; pos="compar"; pos2="prep"}] else
+      let cases = expand_cases cases in
+      [{empty_cats with lemma=lemma; pos="prep"; pos2="prep"; cases=cases; psem=["sem";"nosem"]}]
+  | lemma,"num",[numbers;cases;genders;acms] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      let nsem = num_nsem lemma in
+      [{empty_cats with lemma=lemma; pos="num"; pos2="num"; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; acms=acms; nsem=nsem}]
+  | lemma,"num",[numbers;cases;genders;acms;_] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      let nsem = num_nsem lemma in
+      [{empty_cats with lemma=lemma; pos="num"; pos2="num"; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; acms=acms; nsem=nsem}]
+  | lemma,"numcomp",[] -> [{empty_cats with lemma=lemma; pos="numcomp"; pos2="numcomp"}]
+  | lemma,"intnum",[] ->
+      let numbers,acms =
+        if lemma = "1" || lemma = "-1" then ["sg"],["congr"] else
+        let s = String.get lemma (String.length lemma - 1) in
+        ["pl"],if s = '2' || s = '3' || s = '4' then ["rec";"congr"] else ["rec"] in
+      [{empty_cats with lemma=lemma; pos="intnum"; pos2="num"; numbers=numbers; cases=all_cases; genders=all_genders; persons=["ter"]; acms=acms; nsem=["count"]}]
+  | lemma,"realnum",[] ->
+      [{empty_cats with lemma=lemma; pos="realnum"; pos2="num"; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec"]; nsem=["count"]}]
+  | lemma,"intnum-interval",[] ->
+      [{empty_cats with lemma=lemma; pos="intnum-interval"; pos2="num"; numbers=["pl"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec";"congr"]; nsem=["count"]}]
+  | lemma,"realnum-interval",[] ->
+      [{empty_cats with lemma=lemma; pos="realnum-interval"; pos2="num"; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]; acms=["rec"]; nsem=["count"]}]
+  | lemma,"symbol",[] ->
+      [{empty_cats with lemma=lemma; pos="symbol"; pos2="noun"; numbers=["sg"]; cases=all_cases; genders=all_genders; persons=["ter"]}]
+  | lemma,"ordnum",[] ->
+      [{empty_cats with lemma=lemma; pos="ordnum"; pos2="adj"; numbers=all_numbers; cases=all_cases; genders=all_genders; grads=["pos"]}] (* FIXME: czy dać możliwość więcej niż jednego stopnia *)
+  | lemma,"date",[] ->
+      let nsyn,nsem = noun_type proper lemma "date" in
+      [{empty_cats with lemma=lemma; pos="date"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"date-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "date-interval" in
+      [{empty_cats with lemma=lemma; pos="date-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"hour-minute",[] ->
+      let nsyn,nsem = noun_type proper lemma "hour-minute" in
+      [{empty_cats with lemma=lemma; pos="hour-minute"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"hour",[] ->
+      let nsyn,nsem = noun_type proper lemma "hour" in
+      [{empty_cats with lemma=lemma; pos="hour"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"hour-minute-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "hour-minute-interval" in
+      [{empty_cats with lemma=lemma; pos="hour-minute-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"hour-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "hour-interval" in
+      [{empty_cats with lemma=lemma; pos="hour-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"year",[] ->
+      let nsyn,nsem = noun_type proper lemma "year" in
+      [{empty_cats with lemma=lemma; pos="year"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"year-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "year-interval" in
+      [{empty_cats with lemma=lemma; pos="year-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"day",[] ->
+      let nsyn,nsem = noun_type proper lemma "day" in
+      [{empty_cats with lemma=lemma; pos="day"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"day-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "day-interval" in
+      [{empty_cats with lemma=lemma; pos="day-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"day-month",[] ->
+      let nsyn,nsem = noun_type proper lemma "day-month" in
+      [{empty_cats with lemma=lemma; pos="day-month"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"day-month-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "day-month-interval" in
+      [{empty_cats with lemma=lemma; pos="day-month-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"month-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "month-interval" in
+      [{empty_cats with lemma=lemma; pos="month-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"roman",[] ->
+      let nsyn,nsem = noun_type proper lemma "roman" in
+      [{empty_cats with lemma=lemma; pos="roman-ordnum"; pos2="adj"; numbers=all_numbers; cases=all_cases; genders=all_genders; grads=["pos"]};
+       {empty_cats with lemma=lemma; pos="roman"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"roman-interval",[] ->
+      let nsyn,nsem = noun_type proper lemma "roman-interval" in
+      [{empty_cats with lemma=lemma; pos="roman-interval"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"match-result",[] ->
+      let nsyn,nsem = noun_type proper lemma "match-result" in
+      [{empty_cats with lemma=lemma; pos="match-result"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"url",[] ->
+      let nsyn,nsem = noun_type proper lemma "url" in
+      [{empty_cats with lemma=lemma; pos="url"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"email",[] ->
+      let nsyn,nsem = noun_type proper lemma "email" in
+      [{empty_cats with lemma=lemma; pos="email"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"phone-number",[] ->
+      let nsyn,nsem = noun_type proper lemma "phone-number" in
+      [{empty_cats with lemma=lemma; pos="phone-number"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"postal-code",[] ->
+      let nsyn,nsem = noun_type proper lemma "postal-code" in
+      [{empty_cats with lemma=lemma; pos="postal-code"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"obj-id",[] ->
+      let nsyn,nsem = noun_type proper lemma "obj-id" in
+      [{empty_cats with lemma=lemma; pos="obj-id"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"building-number",[] ->
+      let nsyn,nsem = noun_type proper lemma "building-number" in
+      [{empty_cats with lemma=lemma; pos="building-number"; pos2="symbol"; nsyn=nsyn; nsem=nsem}]
+  | lemma,"fixed",[] -> [{empty_cats with lemma=lemma; pos="fixed"; pos2="fixed"}]
+  | lemma,"adj",[numbers;cases;genders;grads] -> (* FIXME: adjsyn *)
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
+      let genders = expand_genders genders in
+      let pos,pos2 = if StringSet.mem adj_pronoun_lexemes lemma then "apron","pron" else "adj","adj" in
+      [{empty_cats with lemma=lemma; pos=pos; pos2=pos2; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; grads=grads}] (* FIXME: czy dać możliwość więcej niż jednego stopnia *)
+  | lemma,"adjc",[] ->
+      [{empty_cats with lemma=lemma; pos="adjc"; pos2="adj"; cat=cat; coerced=coerced; numbers=["sg"]; cases=["pred"]; genders=["m1";"m2";"m3"]; grads=["pos"]}]
+  | lemma,"adjp",[] ->
+      [{empty_cats with lemma=lemma; pos="adjp"; pos2="adj"; cat=cat; coerced=coerced; numbers=all_numbers; cases=["postp"]; genders=all_genders; grads=["pos"]}]
+  | lemma,"adja",[] -> [{empty_cats with lemma=lemma; cat=cat; coerced=coerced; pos="adja"; pos2="adja"}]
+  | lemma,"adv",[grads] -> [{empty_cats with lemma=lemma; cat=cat; coerced=coerced; pos="adv"; pos2="adv"; grads=grads; modes=adv_mode lemma}]
+  | lemma,"adv",[] -> [{empty_cats with lemma=lemma; cat=cat; coerced=coerced; pos="adv"; pos2="adv"; grads=["pos"]; modes=adv_mode lemma}]
+  | lemma,"ger",[numbers;cases;genders;aspects;negations] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="ger"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; persons=["ter"]; aspects=aspects; negations=negations}] (* FIXME: kwestia osoby przy voc *)
+  | lemma,"pact",[numbers;cases;genders;aspects;negations] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="pact"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; aspects=aspects; negations=negations}]
+  | lemma,"ppas",[numbers;cases;genders;aspects;negations] ->
+      let numbers = expand_numbers numbers in
+      let cases = expand_cases cases in
+      let cases = if Xlist.mem cases "nom" then "pred" :: cases else cases in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="ppas"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; cases=cases; genders=genders; aspects=aspects; negations=negations}]
+  | lemma,"fin",[numbers;persons;aspects] ->  (* FIXME: genders bez przymnogich *)
+      let numbers = expand_numbers numbers in
+      let persons2 = Xlist.fold persons [] (fun l -> function "sec" -> l | s -> s :: l) in
+      let cats = {empty_cats with lemma=lemma; pos="fin"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=all_genders; persons=persons; negations=["aff"; "neg"]; moods=["indicative"]} in
+      (Xlist.map aspects (function
+            "imperf" -> {cats with aspects=["imperf"]; tenses=["pres"]}
+          | "perf" -> {cats with aspects=["perf"]; tenses=["fut"]}
+          | _ -> failwith "clarify_categories")) @
+      (if persons2 = [] then [] else
+        [{empty_cats with lemma=lemma; pos="fin"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}])
+  | lemma,"bedzie",[numbers;persons;aspects] ->
+      let numbers = expand_numbers numbers in
+      let persons2 = Xlist.fold persons [] (fun l -> function "sec" -> l | s -> s :: l) in
+      [{empty_cats with lemma=lemma; pos="bedzie"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}] @
+      (if persons2 = [] then [] else
+        [{empty_cats with lemma=lemma; pos="bedzie"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}])
+  | lemma,"praet",[numbers;genders;aspects;nagl] ->
+      let numbers = expand_numbers numbers in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["past"]}] @
+      (if Xlist.mem aspects "imperf" then
+        [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
+       else [])
+  | lemma,"praet",[numbers;genders;aspects] ->
+      let numbers = expand_numbers numbers in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["past"]}] @
+      (if Xlist.mem aspects "imperf" then
+        [{empty_cats with lemma=lemma; pos="praet"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
+       else [])
+  | lemma,"winien",[numbers;genders;aspects] ->
+      let numbers = expand_numbers numbers in
+      let genders = expand_genders genders in
+      [{empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative";"conditional"]; tenses=["pres"]};
+       {empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["past"]}] @
+      (if Xlist.mem aspects "imperf" then
+        [{empty_cats with lemma=lemma; pos="winien"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=genders; persons=all_persons; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["fut"]}]
+       else [])
+  | lemma,"impt",[numbers;persons;aspects] ->
+      let numbers = expand_numbers numbers in
+      [{empty_cats with lemma=lemma; pos="impt"; pos2="verb"; cat=cat; coerced=coerced; numbers=numbers; genders=all_genders; persons=persons; aspects=aspects; negations=["aff"; "neg"]; moods=["imperative"]; tenses=["fut"]}]
+  | lemma,"imps",[aspects] ->
+      [{empty_cats with lemma=lemma; pos="imps"; pos2="verb"; cat=cat; coerced=coerced; numbers=all_numbers; genders=all_genders; persons=all_persons; aspects=aspects; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["past"]}]
+  | lemma,"pred",[] -> (* FIXME: czy predykatyw zawsze jest niedokonany? *)
+      [{empty_cats with lemma=lemma; pos="pred"; pos2="verb"; cat=cat; coerced=coerced; numbers=["sg"]; genders=[(*"n2"*)"n"]; persons=["ter"]; aspects=["imperf"]; negations=["aff"; "neg"]; moods=["indicative"]; tenses=["pres";"past";"fut"]}]
+  | lemma,"aglt",[numbers;persons;aspects;wok] ->
+      let numbers = expand_numbers numbers in
+      [{empty_cats with lemma=lemma; pos="aglt"; pos2="verb"; numbers=numbers; persons=persons; aspects=aspects}]
+  | lemma,"inf",[aspects] -> [{empty_cats with lemma=lemma; pos="inf"; pos2="verb"; cat=cat; coerced=coerced; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"pcon",[aspects] -> [{empty_cats with lemma=lemma; pos="pcon"; pos2="verb"; cat=cat; coerced=coerced; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"pant",[aspects] -> [{empty_cats with lemma=lemma; pos="pant"; pos2="verb"; cat=cat; coerced=coerced; aspects=aspects; negations=["aff"; "neg"]}]
+  | lemma,"qub",[] ->
+      if StringSet.mem part_set lemma then [{empty_cats with lemma=lemma; pos="part"; pos2="qub"}]
+      else [{empty_cats with lemma=lemma; pos="qub"; pos2="qub"; cat=cat}]
+  | lemma,"comp",[] -> [{empty_cats with lemma=lemma; pos="comp"; pos2="comp"}]
+  | lemma,"conj",[] -> [{empty_cats with lemma=lemma; pos="conj"; pos2="conj"}]
+  | lemma,"interj",[] -> [{empty_cats with lemma=lemma; pos="interj"; pos2="interj"; cat=cat; coerced=coerced}]
+  | lemma,"sinterj",[] -> [{empty_cats with lemma=lemma; pos="sinterj"; pos2="sinterj"; (*cat=cat; coerced=coerced*)}]
+  | lemma,"burk",[] -> [{empty_cats with lemma=lemma; pos="burk"; pos2="burk"}]
+  | ",","interp",[] -> [{empty_cats with lemma=","; pos="conj"; pos2="conj"}]
+  | lemma,"interp",[] -> [{empty_cats with lemma=lemma; pos="interp"; pos2="interp"}]
+  | lemma,"unk",[] ->
+      [{empty_cats with lemma=lemma; pos="unk"; pos2="noun"; numbers=all_numbers; cases=all_cases; genders=all_genders; persons=["ter"]}]
+  | lemma,"xxx",[] ->
+      [{empty_cats with lemma=lemma; pos="xxx"; pos2="noun"; numbers=all_numbers; cases=all_cases; genders=all_genders; persons=["ter"]}]
+  | lemma,"html-tag",[] -> [{empty_cats with lemma=lemma; pos="html-tag"; pos2="html-tag"}]
+  | lemma,"list-item",[] -> [{empty_cats with lemma=lemma; pos="list-item"; pos2="list-item"}]
+  | lemma,c,l -> failwith ("clarify_categories: " ^ lemma ^ ":" ^ c ^ ":" ^ (String.concat ":" (Xlist.map l (String.concat "."))))
+
+(* FIXME: przenieść gdzieś indziej *)
+(* let assign token =
+  match token.ENIAMtokenizerTypes.token with
+    ENIAMtokenizerTypes.Lemma(lemma,pos,interp) -> List.flatten (Xlist.map interp (fun interp -> clarify_categories false (lemma,pos,interp)))
+  | ENIAMtokenizerTypes.Proper(lemma,pos,interp,_) -> List.flatten (Xlist.map interp (fun interp -> clarify_categories true (lemma,pos,interp)))
+  | ENIAMtokenizerTypes.Interp lemma -> clarify_categories false (lemma,"interp",[])
+  | _ -> [] *)
+
+let selector_names = StringSet.of_list [
+    "lemma";"pos";"pos2";"cat";"coerced";"number";"case";"gender";"person";"grad";
+    "praep";"acm";"aspect";"negation";"mood";"tense";"nsyn";"nsem";"ctype";"mode";"psem";
+    "icat";"inumber";"igender";"iperson";"nperson";"ncat";"plemma";
+    "unumber";"ucase";"ugender";"uperson";"amode"]
+
+
+let string_of_selector = function
+    Lemma -> "lemma"
+  (* | NewLemma -> "newlemma" *)
+  | Pos -> "pos"
+  | Pos2 -> "pos2"
+  | Cat -> "cat"
+  | Coerced -> "coerced"
+  | Number -> "number"
+  | Case -> "case"
+  | Gender -> "gender"
+  | Person -> "person"
+  | Grad -> "grad"
+  | Praep -> "praep"
+  | Acm -> "acm"
+  | Aspect -> "aspect"
+  | Negation -> "negation"
+  | Mood -> "mood"
+  | Tense -> "tense"
+  | Nsyn -> "nsyn"
+  | Nsem -> "nsem"
+  | Ctype -> "ctype"
+  | Mode -> "mode"
+  | Psem -> "psem"
+  | Icat -> "icat"
+  | Inumber -> "inumber"
+  | Igender -> "igender"
+  | Iperson -> "iperson"
+  | Nperson -> "nperson"
+  | Ncat -> "ncat"
+  | Plemma -> "plemma"
+  | Unumber -> "unumber"
+  | Ucase -> "ucase"
+  | Ugender -> "ugender"
+  | Uperson -> "uperson"
+  | Amode -> "amode"
+
+let string_of_selectors selectors =
+  String.concat ", " (Xlist.map selectors (fun (cat,rel,l) ->
+      let rel = if rel = Eq then "=" else "!=" in
+      string_of_selector cat ^ rel ^ (String.concat "|" l)))
+
+let selector_of_string = function
+    "lemma" -> Lemma
+  (* | NewLemma -> "newlemma" *)
+  | "pos" -> Pos
+  | "pos2" -> Pos2
+  | "cat" -> Cat
+  | "coerced" -> Coerced
+  | "number" -> Number
+  | "case" -> Case
+  | "gender" -> Gender
+  | "person" -> Person
+  | "grad" -> Grad
+  | "praep" -> Praep
+  | "acm" -> Acm
+  | "aspect" -> Aspect
+  | "negation" -> Negation
+  | "mood" -> Mood
+  | "tense" -> Tense
+  | "nsyn" -> Nsyn
+  | "nsem" -> Nsem
+  | "ctype" -> Ctype
+  | "mode" -> Mode
+  | "psem" -> Psem
+  | "icat" -> Icat
+  | "inumber" -> Inumber
+  | "igender" -> Igender
+  | "iperson" -> Iperson
+  | "nperson" -> Nperson
+  | "ncat" -> Ncat
+  | "plemma" -> Plemma
+  | "unumber" -> Unumber
+  | "ucase" -> Ucase
+  | "ugender" -> Ugender
+  | "uperson" -> Uperson
+  | "amode" -> Amode
+  | s -> failwith ("selector_of_string: " ^ s)
+
+let match_selector cats = function
+    Lemma -> [cats.lemma]
+(* | NewLemma -> [] *)
+  | Pos -> [cats.pos]
+  | Cat -> [cats.cat]
+  | Coerced -> cats.coerced
+  | Number -> cats.numbers
+  | Case -> cats.cases
+  | Gender -> cats.genders
+  | Person -> cats.persons
+  | Grad -> cats.grads
+  | Praep -> cats.praeps
+  | Acm -> cats.acms
+  | Aspect -> cats.aspects
+  | Negation -> cats.negations
+  | Mood -> cats.moods
+  | Tense -> cats.tenses
+  | Nsyn -> cats.nsyn
+  | Nsem -> cats.nsem
+  | Mode -> cats.modes
+  | Psem -> cats.psem
+  | c -> failwith ("match_selector: " ^ string_of_selector c)
+
+let set_selector cats vals = function
+    Number -> {cats with numbers=vals}
+  | Case -> {cats with cases=vals}
+  | Gender -> {cats with genders=vals}
+  | Person -> {cats with persons=vals}
+  | Grad -> {cats with grads=vals}
+  | Praep -> {cats with praeps=vals}
+  | Acm -> {cats with acms=vals}
+  | Aspect -> {cats with aspects=vals}
+  | Negation -> {cats with negations=vals}
+  | Mood -> {cats with moods=vals}
+  | Tense -> {cats with tenses=vals}
+  | Nsyn -> {cats with nsyn=vals}
+  | Nsem -> {cats with nsem=vals}
+  | Mode -> {cats with modes=vals}
+  | Psem -> {cats with psem=vals}
+  | Lemma -> (match vals with [v] -> {cats with lemma=v} | _ -> failwith "set_selector: Lemma")
+  | Pos -> (match vals with [v] -> {cats with pos=v} | _ -> failwith "set_selector: Pos")
+  | Cat -> (match vals with [v] -> {cats with cat=v} | _ -> failwith "set_selector: Cat")
+  | Coerced -> {cats with coerced=vals}
+  | c -> failwith ("set_selector: " ^ string_of_selector c)
+
+let rec apply_selectors cats = function
+    [] -> cats
+  | (sel,Eq,vals) :: l ->
+    let vals = StringSet.intersection (StringSet.of_list (match_selector cats sel)) (StringSet.of_list vals) in
+    if StringSet.is_empty vals then raise Not_found else
+      apply_selectors (set_selector cats (StringSet.to_list vals) sel) l
+  | (sel,Neq,vals) :: l ->
+    let vals = StringSet.difference (StringSet.of_list (match_selector cats sel)) (StringSet.of_list vals) in
+    if StringSet.is_empty vals then raise Not_found else
+      apply_selectors (set_selector cats (StringSet.to_list vals) sel) l
+
+let pos_categories = Xlist.fold [
+    "subst",[Lemma;Cat;Coerced;Number;Case;Gender;Person;Nsyn;Nsem;];
+    "depr",[Lemma;Cat;Coerced;Number;Case;Gender;Person;Nsyn;Nsem;];
+    "ppron12",[Lemma;Number;Case;Gender;Person;];
+    "ppron3",[Lemma;Number;Case;Gender;Person;Praep;];
+    "siebie",[Lemma;Number;Case;Gender;Person;];
+    "prep",[Lemma;Cat;Coerced;Psem;Case;];
+    "compar",[Lemma;Cat;Coerced;Case;];
+    "num",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
+    "numcomp",[Lemma];
+    "intnum",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
+    "realnum",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
+    "intnum-interval",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
+    "realnum-interval",[Lemma;Number;Case;Gender;Person;Acm;Nsem;];
+    "symbol",[Lemma;Number;Case;Gender;Person;];
+    "ordnum",[Lemma;Number;Case;Gender;Grad;];
+    "date",[Lemma;Nsyn;Nsem;];
+    "date-interval",[Lemma;Nsyn;Nsem;];
+    "hour-minute",[Lemma;Nsyn;Nsem;];
+    "hour",[Lemma;Nsyn;Nsem;];
+    "hour-minute-interval",[Lemma;Nsyn;Nsem;];
+    "hour-interval",[Lemma;Nsyn;Nsem;];
+    "year",[Lemma;Nsyn;Nsem;];
+    "year-interval",[Lemma;Nsyn;Nsem;];
+    "day",[Lemma;Nsyn;Nsem;];
+    "day-interval",[Lemma;Nsyn;Nsem;];
+    "day-month",[Lemma;Nsyn;Nsem;];
+    "day-month-interval",[Lemma;Nsyn;Nsem;];
+    "month-interval",[Lemma;Nsyn;Nsem;];
+    "roman-ordnum",[Lemma;Number;Case;Gender;Grad;];
+    "roman",[Lemma;Nsyn;Nsem;];
+    "roman-interval",[Lemma;Nsyn;Nsem;];
+    "match-result",[Lemma;Nsyn;Nsem;];
+    "url",[Lemma;Nsyn;Nsem;];
+    "email",[Lemma;Nsyn;Nsem;];
+    "phone-number",[Lemma;Nsyn;Nsem;];
+    "postal-code",[Lemma;Nsyn;Nsem;];
+    "obj-id",[Lemma;Nsyn;Nsem;];
+    "building-number",[Lemma;Nsyn;Nsem;];
+    "fixed",[Lemma;];
+    "adj",[Lemma;Cat;Coerced;Number;Case;Gender;Grad;];
+    "adjc",[Lemma;Cat;Coerced;Number;Case;Gender;Grad;];
+    "adjp",[Lemma;Cat;Coerced;Number;Case;Gender;Grad;];
+    "apron",[Lemma;Number;Case;Gender;Grad;];
+    "adja",[Lemma;Cat;Coerced;];
+    "adv",[Lemma;Cat;Coerced;Grad;Mode];(* ctype *)
+    "ger",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Case;Gender;Person;Aspect;Negation;];
+    "pact",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Case;Gender;Aspect;Negation;];
+    "ppas",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Case;Gender;Aspect;Negation;];
+    "fin",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "bedzie",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "praet",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "winien",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "impt",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "imps",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "pred",[Lemma;(*NewLemma;*)Cat;Coerced;Number;Gender;Person;Aspect;Negation;Mood;Tense;];
+    "aglt",[Lemma;Number;Person;Aspect;];
+    "inf",[Lemma;(*NewLemma;*)Cat;Coerced;Aspect;Negation;];
+    "pcon",[Lemma;(*NewLemma;*)Cat;Coerced;Aspect;Negation;];
+    "pant",[Lemma;(*NewLemma;*)Cat;Coerced;Aspect;Negation;];
+    "qub",[Lemma;Cat;];
+    "part",[Lemma;];
+    "comp",[Lemma;];(* ctype *)
+    "conj",[Lemma;];(* ctype *)
+    "interj",[Lemma;Cat;Coerced;];
+    "sinterj",[Lemma;];
+    "burk",[Lemma;];
+    "interp",[Lemma;];
+    "unk",[Lemma;Number;Case;Gender;Person;];
+    "xxx",[Lemma;Number;Case;Gender;Person;];
+    "html-tag",[Lemma;];
+    "list-item",[Lemma;];
+  ] StringMap.empty (fun map (k,l) -> StringMap.add map k l)
 @PHRASE_NAMES
   lex infp np prepnp adjp ip cp ncp advp padvp
-  adja prepadjp comprepnp compar measure num aglt aux-fut
+  adja prepadjp comprepnp comparp measure num aglt aux-fut
   aux-past aux-imp qub interj hyphen int
   rparen rparen2 rquot rquot2 rquot3 inclusion
   day-interval day-lex day-month-interval date-interval
@@ -153,8 +153,8 @@ lemma=w,pos=prep,case=loc:      prepnp*lemma*case{\(1+advp*T),/(day-month+day+ye
  
 # komparatywy
 # FIXME: trzeba poprawić comparnp i comparpp w walencji
-pos=compar: QUANT[case=nom&gen&dat&acc&inst] compar*lemma*case{\(1+advp*T),/(np*T*case*T*T+adjp*T*case*T)}{\(1+qub),/(1+inclusion)};
-pos=compar: QUANT[case=postp] compar*lemma*case{\(1+advp*T),/(prepnp*T*T+prepadjp*T*T)}{\(1+qub),/(1+inclusion)};
+pos=compar: QUANT[case=nom&gen&dat&acc&inst] comparp*lemma*case{\(1+advp*T),/(np*T*case*T*T+adjp*T*case*T)}{\(1+qub),/(1+inclusion)};
+pos=compar: QUANT[case=postp] comparp*lemma*case{\(1+advp*T),/(prepnp*T*T+prepadjp*T*T)}{\(1+qub),/(1+inclusion)};
  
 # frazy przymiotnikowe
 # FIXME: let grad = match grads with [grad] -> grad | _ -> failwith "make_adjp: grad" in
@@ -488,3 +488,4 @@ mrowie
 rodzaj
 rozdział
 gmach
+zakres
@@ -59,4 +59,3 @@ let linear_term_array a =
   let l = Int.fold 0 (Array.length a - 1) [] (fun l i ->
     Xml.Element("element",["index",string_of_int i],[linear_term a.(i)]) :: l) in
   Xml.Element("array",[],List.rev l)
-  
@@ -102,7 +102,8 @@ let rec print_simplified_dependency_tree_rec2 file edge upper = function
  
 let rec print_simplified_dependency_tree_rec file edge upper id = function
     Node t ->
-    fprintf file "  %s [label=\"%s\\n%s:%s\\n%s\\n%f\"]\n" id (escape_string t.orth) (escape_string t.lemma) t.pos (escape_string (ENIAM_LCGstringOf.linear_term 0 t.symbol)) t.weight;
+    (* fprintf file "  %s [label=\"%s\\n%s:%s\\n%s\\n%f\"]\n" id (escape_string t.orth) (escape_string t.lemma) t.pos (escape_string (ENIAM_LCGstringOf.linear_term 0 t.symbol)) t.weight; *)
+    fprintf file "  %s [label=\"%s\\n%s:%s\\n%s\"]\n" id (escape_string t.orth) (escape_string t.lemma) t.pos (escape_string (ENIAM_LCGstringOf.linear_term 0 t.symbol));
     print_edge file edge upper id;
     print_simplified_dependency_tree_rec2 file "" id t.args
   | Variant(e,l) ->
@@ -213,7 +213,7 @@ let chart page text_fragments g =
   String.concat "" (List.rev (IntMap.fold layers [] (fun l layer nodes ->
       IntMap.fold nodes l (fun l node1 contents ->
           Xlist.fold contents l (fun l (node2,symbol,sem) ->
-              let s = try IntMap.find text_fragments.(node1) node2 with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
+              let s = try Xlatex.escape_string (IntMap.find text_fragments.(node1) node2) with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
               (Printf.sprintf "%d & %d--%d & %s & $\\begin{array}{l}%s\\end{array}$ & $%s$\\\\\n\\hline\n" layer node1 node2 s symbol sem) :: l))))) ^
   "\\end{longtable}"
  
@@ -221,7 +221,7 @@ let chart2 page text_fragments g =
   let n = match page with "a4" -> "4" | "a1" -> "10" | _ -> "6" in
   "\\begin{longtable}{|l|p{" ^ n ^ "cm}|l|}\n\\hline\n" ^
   String.concat "" (List.rev (ENIAM_LCGchart.fold g [] (fun l (symbol,node1,node2,sem,layer) ->
-      let s = try IntMap.find text_fragments.(node1) node2 with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
+      let s = try Xlatex.escape_string (IntMap.find text_fragments.(node1) node2) with Not_found -> failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2) in
       (Printf.sprintf "%d--%d & %s & $\\begin{array}{l}%s\\end{array}$\\\\\n\\hline\n" node1 node2 s (grammar_symbol 0 symbol)) :: l))) ^
   "\\end{longtable}"
  
@@ -392,6 +392,24 @@ let forward_application references functs args =
       | BracketSet(Forward),_ -> Xlist.fold args l (fun l -> function Bracket(false,rf,arg),arg_sem -> (Bracket(true,rf,arg),arg_sem) :: l | _ -> l)
       | _ -> l)
  
+let forward_application_ignore_brackets references functs args =
+  Xlist.fold functs [] (fun l -> function
+        Bracket(lf,false,funct),sem ->
+        let argst,argsf = Xlist.fold args ([],[]) (fun (argst,argsf) -> function
+              Bracket(_,true,arg),arg_sem -> (arg,arg_sem) :: argst, argsf
+            | Bracket(_,false,arg),arg_sem -> argst, (arg,arg_sem) :: argsf
+            | _ -> argst,argsf) in
+        let l = Xlist.fold (deduce_app references Forward (funct,sem) argst) l (fun l (t,sem) ->
+            (Bracket(lf,true,t), (*LCGreductions.linear_term_beta_reduction2*) sem) :: l) in
+        Xlist.fold (deduce_app references Forward (funct,sem) argsf) l (fun l (t,sem) ->
+            (Bracket(lf,false,t), (*LCGreductions.linear_term_beta_reduction2*) sem) :: l)
+      | Bracket(lf,true,funct),sem ->
+        let args = Xlist.fold args [] (fun args -> function Bracket(_,_,arg),arg_sem -> (arg,arg_sem) :: args | _ -> args) in
+        Xlist.fold (deduce_app references Forward (funct,sem) args) l (fun l (t,sem) ->
+            (Bracket(lf,true,t), (*LCGreductions.linear_term_beta_reduction2*) sem) :: l)
+      | BracketSet(Forward),_ -> Xlist.fold args l (fun l -> function Bracket(_,rf,arg),arg_sem -> (Bracket(true,rf,arg),arg_sem) :: l | _ -> l)
+      | _ -> l)
+
 let forward_application_conll references functs args =
   Xlist.fold functs [] (fun l -> function
         Bracket(_,_,funct),sem ->
@@ -436,6 +454,27 @@ let backward_application references args functs =
       | BracketSet(Backward),_ -> (*print_endline "tt";*) Xlist.fold args l (fun l -> function Bracket(lf,false,arg),arg_sem -> (Bracket(lf,true,arg),arg_sem) :: l | _ -> l)
       | _ -> l)
  
+let backward_application_ignore_brackets references args functs =
+  (* Printf.printf "backward_application: [%s] [%s]\n%!"
+      (String.concat "; " (Xlist.map args (fun (arg,_) -> "'" ^ ENIAM_LCGstringOf.grammar_symbol 1 arg ^ "'")))
+      (String.concat "; " (Xlist.map functs (fun (arg,_) -> "'" ^ ENIAM_LCGstringOf.grammar_symbol 1 arg ^ "'"))); *)
+  Xlist.fold functs [] (fun l -> function
+        Bracket(false,rf,funct),sem ->
+        let argst,argsf = Xlist.fold args ([],[]) (fun (argst,argsf) -> function
+              Bracket(true,_,arg),arg_sem -> (arg,arg_sem) :: argst, argsf
+            | Bracket(false,_,arg),arg_sem -> argst, (arg,arg_sem) :: argsf
+            | _ -> argst,argsf) in
+        let l = Xlist.fold (deduce_app references Backward (funct,sem) argst) l (fun l (t,sem) ->
+            (Bracket(true,rf,t), (*LCGreductions.linear_term_beta_reduction2*) sem) :: l) in
+        Xlist.fold (deduce_app references Backward (funct,sem) argsf) l (fun l (t,sem) ->
+            (Bracket(false,rf,t), (*LCGreductions.linear_term_beta_reduction2*) sem) :: l)
+      | Bracket(true,rf,funct),sem ->
+        let args = Xlist.fold args [] (fun args -> function Bracket(_,_,arg),arg_sem -> (arg,arg_sem) :: args | _ -> args) in
+        Xlist.fold (deduce_app references Backward (funct,sem) args) l (fun l (t,sem) ->
+            (Bracket(true,rf,t), (*LCGreductions.linear_term_beta_reduction2*) sem) :: l)
+      | BracketSet(Backward),_ -> (*print_endline "tt";*) Xlist.fold args l (fun l -> function Bracket(lf,_,arg),arg_sem -> (Bracket(lf,true,arg),arg_sem) :: l | _ -> l)
+      | _ -> l)
+
 let backward_application_conll references args functs =
   (*  Printf.printf "backward_application: [%s] [%s]\n%!"
       (String.concat "; " (Xlist.map args (fun (arg,_) -> "'" ^ ENIAM_LCGstringOf.grammar_symbol 1 arg ^ "'")))
@@ -469,6 +508,7 @@ let backward_cross_composition references args functs =
 (* FIXME: błąd przy redukcji "Jan chce iść spać" *)
  
 let application_rules = [0,backward_application; 0,forward_application]
+let application_rules_ignore_brackets = [0,backward_application_ignore_brackets; 0,forward_application_ignore_brackets]
 let cross_composition_rules = [1,backward_cross_composition;1,forward_cross_composition]
  
 let rec flatten_functor2 l seml = function
@@ -33,6 +33,8 @@ let translate_mode = function
   | ENIAMsubsyntaxTypes.Mate -> Mate
   | ENIAMsubsyntaxTypes.Swigra -> Swigra
   | ENIAMsubsyntaxTypes.POLFIE -> POLFIE
+  | ENIAMsubsyntaxTypes.Error -> Error
+  | ENIAMsubsyntaxTypes.Name -> Name
  
 let rec translate_sentence = function
     ENIAMsubsyntaxTypes.RawSentence s -> RawSentence s
@@ -53,6 +55,7 @@ let rec translate_paragraph = function
          sentence=translate_sentence p.ENIAMsubsyntaxTypes.sentence}))
   | ENIAMsubsyntaxTypes.AltParagraph l -> AltParagraph(Xlist.map l (fun (mode,paragraph) ->
       translate_mode mode, translate_paragraph paragraph))
+  | ENIAMsubsyntaxTypes.ErrorParagraph s -> ErrorParagraph s
  
 let rec translate_text = function
     ENIAMsubsyntaxTypes.RawText s -> RawText s
@@ -61,14 +64,16 @@ let rec translate_text = function
   | ENIAMsubsyntaxTypes.AltText l -> AltText(Xlist.map l (fun (mode,text) ->
       translate_mode mode, translate_text text))
  
-let clarify_categories cats token =
+let clarify_categories cats (*snode*) token =
   match token.ENIAMtokenizerTypes.token with
     ENIAMtokenizerTypes.Lemma(lemma,pos,interp) ->
-      List.flatten (Xlist.map interp (fun interp -> List.flatten (Xlist.map cats (fun (cat,proj) -> ENIAMcategoriesPL.clarify_categories false cat proj (lemma,pos,interp)))))
+      List.flatten (Xlist.map interp (fun interp -> List.flatten (Xlist.map cats (fun (cat,coerced) ->
+        (* Printf.printf "lemma=%s pos=%s cat=%s coerced=%s\n%!" lemma pos cat (String.concat "," coerced); *)
+        ENIAMcategoriesPL.clarify_categories false cat coerced (*snode*) (lemma,pos,interp)))))
   | ENIAMtokenizerTypes.Proper(lemma,pos,interp,senses2) ->
-      List.flatten (Xlist.map interp (fun interp -> List.flatten (Xlist.map cats (fun (cat,proj) -> ENIAMcategoriesPL.clarify_categories true cat proj (lemma,pos,interp)))))
+      List.flatten (Xlist.map interp (fun interp -> List.flatten (Xlist.map cats (fun (cat,coerced) -> ENIAMcategoriesPL.clarify_categories true cat coerced (*snode*) (lemma,pos,interp)))))
   | ENIAMtokenizerTypes.Interp lemma ->
-      List.flatten (Xlist.map cats (fun (cat,proj) -> ENIAMcategoriesPL.clarify_categories false cat proj (lemma,"interp",[])))
+      List.flatten (Xlist.map cats (fun (cat,coerced) -> ENIAMcategoriesPL.clarify_categories false cat coerced (*snode*) (lemma,"interp",[])))
   | _ -> []
  
 let create_chart rules tokens lex_sems paths last =
@@ -79,9 +84,9 @@ let create_chart rules tokens lex_sems paths last =
       let s = ExtArray.get lex_sems id in
       ENIAM_LCGrenderer.reset_variable_names ();
       ENIAM_LCGrenderer.add_variable_numbers ();
-      if s.ENIAMlexSemanticsTypes.schemata = [] then failwith ("create_chart: no schema for token=" ^ t.ENIAMtokenizerTypes.orth ^ " lemma=" ^ ENIAMtokens.get_lemma t.ENIAMtokenizerTypes.token) else
-      Xlist.fold s.ENIAMlexSemanticsTypes.schemata chart (fun chart (selectors,cats,schema) ->
-        let cats = clarify_categories cats t in
+      (* if s.ENIAMlexSemanticsTypes.schemata = [] then failwith ("create_chart: no schema for token=" ^ t.ENIAMtokenizerTypes.orth ^ " lemma=" ^ ENIAMtokens.get_lemma t.ENIAMtokenizerTypes.token) else *)
+      Xlist.fold s.ENIAMlexSemanticsTypes.schemata chart (fun chart (selectors,cats,(*snode,*)schema) ->
+        let cats = clarify_categories cats (*snode*) t in
       (* let chart = ENIAM_LCGchart.add_inc_list chart lnode rnode s.ENIAMlexSemanticsTypes.lex_entries 0 in *)
         let l = ENIAM_LCGlexicon.create_entries rules id t.ENIAMtokenizerTypes.orth cats [selectors,schema] s.ENIAMlexSemanticsTypes.lex_entries in
         ENIAM_LCGchart.add_inc_list chart lnode rnode l 0)) in
@@ -110,10 +115,11 @@ let create_dep_chart dep_rules tokens lex_sems paths =
       let s = ExtArray.get lex_sems id in
       ENIAM_LCGrenderer.reset_variable_names ();
       ENIAM_LCGrenderer.add_variable_numbers ();
-      let cats = clarify_categories ["X",["X"]] t in
-      let schemata = Xlist.map s.ENIAMlexSemanticsTypes.schemata (fun (selectors,_,schema) -> selectors,schema) in
-      let l = ENIAM_LCGlexicon.create_entries dep_rules id t.ENIAMtokenizerTypes.orth cats schemata s.ENIAMlexSemanticsTypes.lex_entries in
-      IntMap.add nodes i l) in
+      Xlist.fold s.ENIAMlexSemanticsTypes.schemata nodes (fun nodes (selectors,cats,(*snode,*)schema) ->
+        let cats = clarify_categories ["X",["X"]] (*snode*) t in
+      (* let chart = ENIAM_LCGchart.add_inc_list chart lnode rnode s.ENIAMlexSemanticsTypes.lex_entries 0 in *)
+        let l = ENIAM_LCGlexicon.create_entries dep_rules id t.ENIAMtokenizerTypes.orth cats [selectors,schema] s.ENIAMlexSemanticsTypes.lex_entries in
+        IntMap.add_inc nodes i l (fun l2 -> l @ l2))) in
   (* print_endline "create_dep_chart 3"; *)
   let x = dep_create_rec nodes sons 0 in
   (* print_endline "create_dep_chart 4"; *)
@@ -134,10 +140,27 @@ let create_text_fragments tokens paths last =
     text_fragments.(i) <- map);
   text_fragments
  
+(*let create_beg_positions tokens paths last =
+  let beg_positions = Array.make last (-1) in
+  Xlist.iter paths (fun (id,lnode,rnode) ->
+    let t = ExtArray.get tokens id in
+    beg_positions.(lnode) <- t.ENIAMtokenizerTypes.beg);
+  beg_positions
+
+let create_end_positions tokens paths last =
+  let end_positions = Array.make last (-1) in
+  Xlist.iter paths (fun (id,lnode,rnode) ->
+    let t = ExtArray.get tokens id in
+    end_positions.(rnode) <- t.ENIAMtokenizerTypes.beg + t.ENIAMtokenizerTypes.len);
+  end_positions*)
+
 let eniam_parse_sentence timeout verbosity rules tokens lex_sems paths last =
   ENIAM_LCGreductions.reset_variant_label ();
   let result = {empty_eniam_parse_result with paths_size = Xlist.size paths} in
-  let result = if verbosity = 0 then result else {result with text_fragments=create_text_fragments tokens paths last} in
+  let result = if verbosity = 0 then result else {result with
+    text_fragments=create_text_fragments tokens paths last;
+    (*beg_positions=create_beg_positions tokens paths last;
+    end_positions=create_end_positions tokens paths last;*)} in
   let time1 = time_fun () in
   try
     (* print_endline "eniam_parse_sentence 1"; *)
@@ -469,6 +492,7 @@ let eniam_semantic_processing verbosity tokens lex_sems (result : eniam_parse_re
       let graph = ENIAMsemGraph.greater_simplify graph in
 (*    let graph = ENIAMsemGraph.manage_quantification graph in  *)
       let graph = ENIAMsemGraph.simplify_gender graph in
+      let graph = ENIAMsemGraph.manage_variant_labels graph in
       let result = (*if verbosity = 0 then result else*) {result with semantic_graph11=graph; semantic_graph12=graph} in
       graph,result
     with e -> ENIAMsemTypes.Dot,{result with status=SemGraphError; msg=string_of_exn e} in
@@ -78,7 +78,7 @@ type semantic_processing_result = {
   }
 *)
 type mode =
-    Raw | Struct | CONLL | ENIAM | Mate | Swigra | POLFIE
+    Raw | Struct | CONLL | ENIAM | Mate | Swigra | POLFIE | Error | Name
  
 type sentence =
     RawSentence of string
@@ -98,6 +98,7 @@ and paragraph =
     RawParagraph of string
   | StructParagraph of paragraph_record list (* zdania *)
   | AltParagraph of (mode * paragraph) list
+  | ErrorParagraph of string
  
 type text =
     RawText of string
@@ -267,6 +268,7 @@ let rec map_paragraph mode f = function
       let l = Xlist.rev_map l (fun (mode,paragraph) ->
         mode, map_paragraph mode f paragraph) in
       AltParagraph(List.rev l)
+  | ErrorParagraph s -> ErrorParagraph s
  
 let rec map_text mode f = function
     RawText s -> RawText s
@@ -295,6 +297,7 @@ let rec fold_paragraph mode s f = function
   | AltParagraph l ->
     Xlist.fold l s (fun s (mode,paragraph) ->
         fold_paragraph mode s f paragraph)
+  | ErrorParagraph _ -> s
  
 let rec fold_text mode s f = function
     RawText _ -> s
@@ -306,6 +309,7 @@ let rec fold_text mode s f = function
         fold_text mode s f text)
  
 let rules_filename = ENIAM_LCGlexiconTypes.resource_path ^ "/LCGlexicon/lexicon-pl.dic"
+let colours_filename = ENIAMwalTypes.data_path ^ "/colours.tab"
  
 let lcg_rules = ref ([] : (int * (ENIAM_LCGtypes.linear_term ExtArray.t ->
           (ENIAM_LCGtypes.SymbolMap.key * ENIAM_LCGtypes.linear_term) list ->
@@ -64,6 +64,7 @@ let rec paragraph m = function
       Xml.Element("StructParagraph",set_mode m,Xlist.map sentences (fun p ->
         Xml.Element("Sentence",["id",p.id;"beg",string_of_int p.beg;"len",string_of_int p.len;"next",string_of_int p.next],[sentence "" p.sentence])))
   | AltParagraph l -> Xml.Element("AltParagraph",set_mode m,Xlist.map l (fun (m,t) -> paragraph (ENIAMvisualization.string_of_mode m) t))
+  | ErrorParagraph s -> Xml.Element("ErrorParagraph",set_mode m,[Xml.PCData s])
  
 let rec text m = function
     RawText s -> Xml.Element("RawText",set_mode m,[Xml.PCData s])
@@ -69,6 +69,7 @@ let rec select_sentence_modes_paragraph = function
       let l = Xlist.rev_map l (fun (mode,paragraph) ->
         mode, select_sentence_modes_paragraph paragraph) in
       AltParagraph(List.rev l)
+  | ErrorParagraph s -> ErrorParagraph s
  
 let rec select_sentence_modes_text = function
     RawText s -> RawText s
@@ -148,6 +149,7 @@ let rec select_sentences_paragraph mode = function
       let l = Xlist.rev_map l (fun (mode,paragraph) ->
         mode, select_sentences_paragraph mode paragraph) in
       AltParagraph(List.rev l)
+  | ErrorParagraph s -> ErrorParagraph s
  
 let rec select_sentences_text mode = function
     RawText s -> RawText s
@@ -24,7 +24,7 @@ open ENIAMtokenizerTypes
 open ENIAMexecTypes
  
 let string_of_status = function
-    Idle -> "Idle"
+      Idle -> "Idle"
     | PreprocessingError -> "PreprocessingError"
     | LexiconError -> "LexiconError"
     | ParseError -> "ParseError"
@@ -657,6 +657,8 @@ let string_of_mode = function
   | Mate -> "Mate"
   | Swigra -> "Swigra"
   | POLFIE -> "POLFIE"
+  | Error -> "Error"
+  | Name -> "Name"
 (*
 (*let rec string_of_sentence = function
     RawSentence s -> sprintf "RawSentence(%s)" s
@@ -775,6 +777,94 @@ let create_latex_dep_chart path name dep_chart =
   LatexMain.latex_compile_and_clean path name
 *)
  
+let rec extract_pos_cat_internal vars = function
+  | Atom x -> x
+  | AVar x -> (try extract_pos_cat_internal vars (Xlist.assoc vars x) with Not_found -> failwith "extract_pos_cat_internal")
+  | With l -> String.concat "&" (Xlist.map l (extract_pos_cat_internal vars))
+  | Zero -> "0"
+  | Top -> "T"
+
+let rec extract_pos_cat vars = function
+  | Tensor [] -> failwith "extract_pos_cat: ni"
+  | Tensor [pos] -> extract_pos_cat_internal vars pos
+  | Tensor [pos;_] -> extract_pos_cat_internal vars pos
+  | Tensor [pos;_;_] -> extract_pos_cat_internal vars pos
+  | Tensor (Atom "num" :: _) -> "Number"
+  | Tensor (Atom "aglt" :: _) -> "Aglt"
+  | Tensor (Atom "prepnp" :: _) -> "Prep"
+  | Tensor (Atom "comparp" :: _) -> "Compar"
+  | Tensor (Atom "cp" :: _) -> "Comp"
+  | Tensor [_;cat;_;_] -> extract_pos_cat_internal vars cat
+  | Tensor [_;_;cat;_;_] -> extract_pos_cat_internal vars cat
+  | Tensor [_;_;_;cat;_;_] -> extract_pos_cat_internal vars cat
+  | Tensor [_;_;_;_;cat;_;_] -> extract_pos_cat_internal vars cat
+  | Tensor [_;_;_;_;_;cat;_;_] -> extract_pos_cat_internal vars cat
+  | Tensor [_;_;_;_;_;_;cat;_;_] -> extract_pos_cat_internal vars cat
+  (* | Tensor (pos :: cat :: _) -> (*extract_pos_cat_internal vars pos ^ "*" ^*) extract_pos_cat_internal vars cat *)
+  | Tensor _ as t -> print_endline ("Unknown symbol " ^ ENIAM_LCGstringOf.grammar_symbol 0 t); "Unknown"
+  | Plus l -> failwith "extract_pos_cat: ni"
+  | Imp(s,d,t2) -> extract_pos_cat vars s
+  | One -> failwith "extract_pos_cat: ni"
+  | ImpSet(s,l) -> extract_pos_cat vars s
+  | WithVar(v,g,e,s) -> extract_pos_cat ((v,g) :: vars) s
+  | Star s -> failwith "extract_pos_cat: ni"
+  | Bracket(lf,rf,s) -> extract_pos_cat vars s
+  | BracketSet d -> "BracketSet"
+  | Maybe s -> failwith "extract_pos_cat: ni"
+
+let get_text_fragment text_fragments node1 node2 =
+  try IntMap.find text_fragments.(node1) node2
+  with (*Not_found*)_ -> "???"(*failwith (Printf.sprintf "chart: text_fragment not found %d-%d" node1 node2)*)
+
+let omited = StringSet.of_list ["<subst>";"<depr>";"<ppron12>";"<ppron3>";"<siebie>";"<prep>";
+  "<num>";"<intnum>";"<realnum>";"<intnum-interval>";"<realnum-interval>";"<symbol>";"<ordnum>";
+  "<date>";"<date-interval>";"<hour-minute>";"<hour>";"<hour-minute-interval>";"<hour-interval>";
+  "<year>";"<year-interval>";"<day>";"<day-interval>";"<day-month>";"<day-month-interval>";
+  "<month-interval>";"<roman>";"<roman-interval>";"<roman-ordnum>";"<match-result>";"<url>";
+  "<email>";"<obj-id>";"<adj>";"<apron>";"<adjc>";"<adjp>";"<adja>";"<adv>";"<ger>";"<pact>";
+  "<ppas>";"<fin>";"<bedzie>";"<praet>";"<winien>";"<impt>";"<imps>";"<pred>";"<aglt>";"<inf>";
+  "<pcon>";"<pant>";"<qub>";"<comp>";"<compar>";"<conj>";"<interj>";"<sinterj>";"<burk>";
+  "<interp>";"<part>";"<unk>";"<building-number>";"<html-tag>";"<list-item>";"<numcomp>";
+  "<phone-number>";"<postal-code>";"<sentence>";"<paragraph>"]
+
+let cat_tokens_sequence text_fragments g =
+  let _,_,l = ENIAM_LCGchart.fold g (0,0,[]) (fun (m,n,l) (symbol,node1,node2,sem,layer) ->
+    node1,node2,
+    (if m < node1 then
+      if n < node1 then [n, node1, get_text_fragment text_fragments n node1, "null"]
+      else if n = node1 then []
+      else [node1, n, get_text_fragment text_fragments node1 n, "overlap"]
+    else if m = node1 then
+      if n < node2 then [m, n, get_text_fragment text_fragments m n, "overlap"]
+      else if n = node2 then []
+      else [node1, node2, get_text_fragment text_fragments node1 node2, "overlap"]
+    else failwith "cat_tokens_sequence") @
+    [node1, node2, get_text_fragment text_fragments node1 node2, extract_pos_cat [] symbol] @ l) in
+  let map = Xlist.fold l IntMap.empty (fun map (m,n,text,symbol) ->
+    IntMap.add_inc map (1000000*m+n) [text,symbol] (fun l -> (text,symbol) :: l)) in
+  let map = IntMap.map map (fun l ->
+    let t,ov,set = Xlist.fold l ("",false,StringSet.empty) (fun (t,ov,set) (text,symbol) ->
+      if symbol = "null" then text,ov,set
+      else if symbol = "overlap" then t,true,set
+      else if StringSet.mem omited symbol then text,ov,set
+      else t,ov,StringSet.add set symbol) in
+    let l = if StringSet.is_empty set then [t] else StringSet.to_list set in
+    if ov then "OVERLAP{" ^ String.concat " " l ^ "}" else
+    match l with
+      [t] -> t
+    | _ -> "{" ^ String.concat " " l ^ "}") in
+  let l = List.sort compare (IntMap.fold map [] (fun l k texts -> (k,texts) :: l)) in
+(*  let l = Xlist.sort l (fun (m1,n1,text1,symbol1) (m2,n2,text2,symbol2) ->
+    if m1 <> m2 then compare m1 m2 else
+    if n1 <> n2 then compare n1 n2 else
+    compare symbol1 symbol2) in
+  let l = if l = [] then l else
+    Xlist.fold (List.tl l) [List.hd l] (fun l a ->
+      match l with
+        [] -> failwith "cat_tokens_sequence"
+      | b :: l -> if a = b then b :: l else a :: b :: l) in*)
+  String.concat " " (Xlist.map l (fun (n,texts) -> texts))
+
  
 (* verbosity:
   0 -> jedynie informacja o statusie zdania
@@ -785,13 +875,13 @@ let create_latex_dep_chart path name dep_chart =
 let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam_parse_result) =
   match result.status with
     Idle -> "<font color=\"red\">idle</font>\n"
-  | LexiconError -> sprintf "<font color=\"red\">error_lex</font>: %s paths_size=%d\n" result.msg result.paths_size
+  | LexiconError -> sprintf "<font color=\"red\">error_lex</font>: %s paths_size=%d\n" (escape_html result.msg) result.paths_size
   | ParseError ->
       if verbosity = 0 then () else (
         ENIAM_LCGlatexOf.print_chart path (file_prefix ^ "_1_chart") "a1" result.text_fragments result.chart1;
         ENIAM_LCGlatexOf.print_chart path (file_prefix ^ "_2_chart") "a4" result.text_fragments result.chart2;
         ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_2_references") "a0" result.references2);
-      sprintf "<font color=\"red\">error_parse</font>: %s paths_size=%d\n" result.msg result.paths_size ^
+      sprintf "<font color=\"red\">error_parse</font>: %s paths_size=%d\n" (escape_html result.msg) result.paths_size ^
       (if verbosity = 0 then "" else
         sprintf "<BR><A HREF=\"%s_1_chart.pdf\">Chart 1</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_2_chart.pdf\">Chart 2</A>\n" file_prefix ^
@@ -803,7 +893,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_2_references") "a0" result.references2);
       if verbosity = 0 then () else (
         ENIAM_LCGlatexOf.print_chart path (file_prefix ^ "_2_chart") "a4" result.text_fragments result.chart2);
-      sprintf "<font color=\"red\">timeout</font>: %s paths_size=%d\n" result.msg result.paths_size ^
+      sprintf "<font color=\"red\">timeout</font>: %s paths_size=%d\n" (escape_html result.msg) result.paths_size ^
       (if verbosity < 2 then "" else
         sprintf "<BR><A HREF=\"%s_1_chart.pdf\">Chart 1</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_2_references.pdf\">References 2</A>\n" file_prefix) ^
@@ -829,6 +919,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         sprintf "<BR><A HREF=\"%s_3_references.pdf\">References 3</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_3_chart.pdf\">Chart 3</A>\n" file_prefix) ^
       (if verbosity = 0 then "" else
+        sprintf "<BR>%s\n" (escape_html (cat_tokens_sequence result.text_fragments (ENIAM_LCGchart.select_maximal result.chart1))) ^
         sprintf "<BR><A HREF=\"%s_3_chart_selection.pdf\">Chart 3 Selection</A>\n" file_prefix) ^
       ""
   | ReductionError ->
@@ -840,7 +931,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         ENIAM_LCGlatexOf.print_chart path (file_prefix ^ "_1_chart") "a1" result.text_fragments result.chart1;
         ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_3_references") "a0" result.references3);
       (if verbosity < 2 then "" else
-        sprintf "<font color=\"red\">error_reduction</font>: %s paths_size=%d chart_size=%d\n" result.msg result.paths_size result.chart_size ^
+        sprintf "<font color=\"red\">error_reduction</font>: %s paths_size=%d chart_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size ^
         sprintf "<BR><A HREF=\"%s_2_chart.pdf\">Chart 2</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_2_references.pdf\">References 2</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_3_chart.pdf\">Chart 3</A>\n" file_prefix) ^
@@ -898,7 +989,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
           Printf.fprintf file "\\[%s\\]\n" (ENIAM_LCGlatexOf.linear_term 0 result.term4));
         Xlatex.latex_compile_and_clean path (file_prefix ^ "_4_term");
         ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_4_dependency_tree") "a0" result.dependency_tree4);
-      sprintf "<font color=\"red\">error_reduction2</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
+      sprintf "<font color=\"red\">error_reduction2</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity < 2 then "" else
         sprintf "<BR><A HREF=\"%s_1_chart.pdf\">Chart 1</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_2_chart.pdf\">Chart 2</A>\n" file_prefix ^
@@ -928,7 +1019,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_6b_dependency_tree") result.dependency_tree6b;
         ENIAM_LCGgraphOf.print_simplified_dependency_tree path (file_prefix ^ "_6a_simple_dependency_tree") result.dependency_tree6a;
         ENIAM_LCGgraphOf.print_simplified_dependency_tree path (file_prefix ^ "_6b_simple_dependency_tree") result.dependency_tree6b);
-      sprintf "<font color=\"red\">error_reduction3</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
+      sprintf "<font color=\"red\">error_reduction3</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity < 2 then "" else
         sprintf "<BR><A HREF=\"%s_1_chart.pdf\">Chart 1</A>\n" file_prefix ^
         sprintf "<BR><A HREF=\"%s_2_chart.pdf\">Chart 2</A>\n" file_prefix ^
@@ -966,8 +1057,9 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_6b_dependency_tree") "a4" result.dependency_tree6b);
       if verbosity = 0 then () else (
         ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_6a_dependency_tree") result.dependency_tree6a;
+        ENIAM_LCGgraphOf.print_simplified_dependency_tree path (file_prefix ^ "_6a_simple_dependency_tree") result.dependency_tree6a);
+      if verbosity < 2 then () else (
         ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_6b_dependency_tree") result.dependency_tree6b;
-        ENIAM_LCGgraphOf.print_simplified_dependency_tree path (file_prefix ^ "_6a_simple_dependency_tree") result.dependency_tree6a;
         ENIAM_LCGgraphOf.print_simplified_dependency_tree path (file_prefix ^ "_6b_simple_dependency_tree") result.dependency_tree6b);
       sprintf "parsed: paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity < 2 then "" else
@@ -984,10 +1076,11 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
       (if verbosity = 0 then "" else
         (if img <> 2 then sprintf "<BR><A HREF=\"%s_6a_dependency_tree.png\">Dependency Tree 6a</A>\n" file_prefix
          else sprintf "<BR><IMG SRC=\"%s_6a_dependency_tree.png\">\n" file_prefix) ^
+        (if img <> 1 then sprintf "<BR><A HREF=\"%s_6a_simple_dependency_tree.png\">Simplified Dependency Tree 6a</A>\n" file_prefix
+         else sprintf "<BR><IMG SRC=\"%s_6a_simple_dependency_tree.png\">\n" file_prefix)) ^
+      (if verbosity < 2 then "" else
         (if img <> 2 then sprintf "<BR><A HREF=\"%s_6b_dependency_tree.png\">Dependency Tree 6b</A>\n" file_prefix
          else sprintf "<BR><IMG SRC=\"%s_6b_dependency_tree.png\">\n" file_prefix) ^
-        (if img <> 1 then sprintf "<BR><A HREF=\"%s_6a_simple_dependency_tree.png\">Simplified Dependency Tree 6a</A>\n" file_prefix
-         else sprintf "<BR><IMG SRC=\"%s_6a_simple_dependency_tree.png\">\n" file_prefix) ^
         (if img <> 1 then sprintf "<BR><A HREF=\"%s_6b_simple_dependency_tree.png\">Simplified Dependency Tree 6b</A>\n" file_prefix
          else sprintf "<BR><IMG SRC=\"%s_6b_simple_dependency_tree.png\">\n" file_prefix)) ^
       ""
@@ -999,7 +1092,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         if ExtArray.size result.dependency_tree8 <> 0 then ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_8_dependency_tree") "a3" result.dependency_tree8;
         if result.dependency_tree9 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a3" result.dependency_tree9;
         if result.dependency_tree9 <> [| |] then ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") result.dependency_tree9);
-      sprintf "<font color=\"red\">error_sem_valence</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
+      sprintf "<font color=\"red\">error_sem_valence</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity = 0 then "" else
         sprintf "<BR><A HREF=\"%s_6b_dependency_tree.pdf\">Dependency Tree References 6b</A>\n" file_prefix ^
         (if result.dependency_tree7 <> [| |] then sprintf "<BR><A HREF=\"%s_7_dependency_tree.pdf\">Dependency Tree References 7</A>\n" file_prefix else "")  ^
@@ -1027,7 +1120,7 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
         if ExtArray.size result.dependency_tree8 <> 0 then ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_8_dependency_tree") "a3" result.dependency_tree8;
         if result.dependency_tree9 <> [| |] then ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a3" result.dependency_tree9;
         if result.dependency_tree9 <> [| |] then ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") result.dependency_tree9));
-      sprintf "<font color=\"red\">error_sem_graph</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
+      sprintf "<font color=\"red\">error_sem_graph</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity = 2 then
         sprintf "<BR><A HREF=\"%s_6b_dependency_tree.pdf\">Dependency Tree References 6b</A>\n" file_prefix ^
         (if result.semantic_graph10 <> [| |] then sprintf "<BR><A HREF=\"%s_10_semantic_graph.pdf\">Semantic Graph References 10</A>\n" file_prefix else "") ^
@@ -1050,14 +1143,32 @@ let html_of_eniam_sentence path file_prefix img verbosity tokens (result : eniam
   | SemGraphError2 ->
       if verbosity = 0 then () else (
         ENIAMsemGraphOf.print_semantic_graph2 path (file_prefix ^ "_11_semantic_graph") "" result.semantic_graph11);
-      sprintf "<font color=\"red\">error_sem_graph2</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
+      sprintf "<font color=\"red\">error_sem_graph2</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size result.dependency_tree_size ^
       (if verbosity = 0 then "" else
         sprintf "<BR><IMG SRC=\"%s_11_semantic_graph.png\">\n" file_prefix)  ^
       ""
   | SemNotValidated ->
+      if verbosity < 2 then () else (
+        ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_6b_dependency_tree") result.dependency_tree6b;
+        ENIAM_LCGgraphOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") result.dependency_tree9;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_6b_dependency_tree") "a3" result.dependency_tree6b;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_7_dependency_tree") "a2" result.dependency_tree7;
+        ENIAM_LCGlatexOf.print_references path (file_prefix ^ "_8_dependency_tree") "a3" result.dependency_tree8;
+        ENIAM_LCGlatexOf.print_dependency_tree path (file_prefix ^ "_9_dependency_tree") "a3" result.dependency_tree9;
+        ENIAMsemLatexOf.print_semantic_graph path (file_prefix ^ "_10_semantic_graph") "a3" result.semantic_graph10;
+        ENIAMsemGraphOf.print_semantic_graph2 path (file_prefix ^ "_11_semantic_graph") "" result.semantic_graph11);
       if verbosity = 0 then () else (
         ENIAMsemGraphOf.print_semantic_graph2 path (file_prefix ^ "_12_semantic_graph") "" result.semantic_graph12);
-      sprintf "<font color=\"red\">sem_not_validated</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" result.msg result.paths_size result.chart_size result.dependency_tree_size ^
+      sprintf "<font color=\"red\">sem_not_validated</font>: %s paths_size=%d chart_size=%d dependency_tree_size=%d\n" (escape_html result.msg) result.paths_size result.chart_size result.dependency_tree_size ^
+      (if verbosity < 2 then "" else
+        sprintf "<BR><A HREF=\"%s_6b_dependency_tree.pdf\">Dependency Tree References 6b</A>\n" file_prefix  ^
+        sprintf "<BR><A HREF=\"%s_7_dependency_tree.pdf\">Dependency Tree References 7</A>\n" file_prefix  ^
+        sprintf "<BR><A HREF=\"%s_8_dependency_tree.pdf\">Dependency Tree References 8</A>\n" file_prefix  ^
+        sprintf "<BR><A HREF=\"%s_9_dependency_tree.pdf\">Dependency Tree References 9</A>\n" file_prefix  ^
+        sprintf "<BR><IMG SRC=\"%s_6b_dependency_tree.png\">\n" file_prefix ^
+        sprintf "<BR><IMG SRC=\"%s_9_dependency_tree.png\">\n" file_prefix ^
+        sprintf "<BR><A HREF=\"%s_10_semantic_graph.pdf\">Semantic Graph References 10</A>\n" file_prefix  ^
+        sprintf "<BR><IMG SRC=\"%s_11_semantic_graph.png\">\n" file_prefix)  ^
       (if verbosity = 0 then "" else
         sprintf "<BR><IMG SRC=\"%s_12_semantic_graph.png\">\n" file_prefix)  ^
       ""
@@ -1164,6 +1275,8 @@ let file_prefix_of_mode = function
   | Mate -> "M"
   | Swigra -> "S"
   | POLFIE -> "P"
+  | Error -> "Er"
+  | Name -> "N"
  
 let rec html_of_sentence path file_prefix mode img verbosity tokens = function
     RawSentence s -> escape_html s
@@ -1196,6 +1309,7 @@ let rec html_of_paragraph path mode img verbosity tokens = function
      String.concat "\n" (Xlist.map l (fun (mode,paragraph) ->
        sprintf "<tr><td>%s</td><td>%s</td></tr>" (string_of_mode mode) (html_of_paragraph path mode img verbosity tokens paragraph))) ^
      "</table>"
+  | ErrorParagraph s -> sprintf "<font color=\"red\">subsyntax_error</font>: %s\n" (escape_html s)
  
 let rec html_of_text path mode img verbosity tokens = function
     RawText s -> escape_html s
@@ -1229,6 +1343,7 @@ let rec find_prev_next_paragraph rev = function
   | StructParagraph sentences ->
       Xlist.fold sentences rev (fun rev p -> find_prev_next_sentence p.id p.file_prefix rev p.sentence)
   | AltParagraph l -> Xlist.fold l rev (fun rev (mode,paragraph) -> find_prev_next_paragraph rev paragraph)
+  | ErrorParagraph s -> rev
  
 let rec make_prev_next_map map prev = function
     [x] -> StringMap.add map x (prev,"")
@@ -1288,7 +1403,6 @@ let rec print_main_result_sentence path cg_bin_path results_web_path id file_pre
   | AltSentence((Raw,RawSentence query) :: sentences) ->
       File.file_out (path ^ "page" ^ id ^ "_" ^ file_prefix ^ ".html") (fun file ->
         print_sentence_to_file path cg_bin_path results_web_path true id file_prefix prev_next_map query sentences file)
-  (* | AltSentence[Raw,RawSentence query] -> print_not_parsed_main_result path cg_bin_path results_web_path id file_prefix query pid prev_next_map *)
   | _ -> failwith "print_main_result_sentence: ni"
  
 let rec print_main_result_paragraph path cg_bin_path results_web_path id tokens prev_next_map = function
@@ -1296,6 +1410,8 @@ let rec print_main_result_paragraph path cg_bin_path results_web_path id tokens 
   | StructParagraph sentences ->
       Xlist.iter sentences (fun p -> print_main_result_sentence path cg_bin_path results_web_path id p.file_prefix tokens p.id prev_next_map p.sentence)
   | AltParagraph l -> Xlist.iter l (fun (mode,paragraph) -> print_main_result_paragraph path cg_bin_path results_web_path id tokens prev_next_map paragraph)
+  | ErrorParagraph s -> File.file_out (path ^ "page" ^ id ^ "_Er.html") (fun file ->
+      print_sentence_to_file path cg_bin_path results_web_path false id "Er" prev_next_map ("ErrorParagraph: " ^ s) [] file)
  
 let rec print_main_result_text path cg_bin_path results_web_path id tokens = function
     RawText s -> ()
@@ -1309,8 +1425,7 @@ let rec print_main_result_first_page_sentence path cg_bin_path results_web_path 
     AltSentence[Raw,_;Struct,QuotedSentences sentences] ->
       let p = List.hd sentences in
       print_main_result_first_page_sentence path cg_bin_path results_web_path id p.file_prefix tokens p.id prev_next_map p.sentence
-(*    | AltSentence[Raw,RawSentence query] -> print_not_parsed_main_result_first_page path cg_bin_path results_web_path id file_prefix query pid prev_next_map
-*)  | AltSentence((Raw,RawSentence query) :: sentences) ->
+  | AltSentence((Raw,RawSentence query) :: sentences) ->
       print_sentence_to_file path cg_bin_path results_web_path false id file_prefix prev_next_map query sentences stdout
   | _ -> failwith "print_main_result_first_page_sentence: ni"
  
@@ -1320,6 +1435,7 @@ let rec print_main_result_first_page_paragraph path cg_bin_path results_web_path
       let p = List.hd sentences in
       print_main_result_first_page_sentence path cg_bin_path results_web_path id p.file_prefix tokens p.id prev_next_map p.sentence
   | AltParagraph l -> Xlist.iter l (fun (mode,paragraph) -> print_main_result_first_page_paragraph path cg_bin_path results_web_path id tokens prev_next_map paragraph)
+  | ErrorParagraph s -> print_sentence_to_file path cg_bin_path results_web_path false id "Er" prev_next_map ("ErrorParagraph: " ^ s) [] stdout
  
 let rec print_main_result_first_page_text path cg_bin_path results_web_path id tokens = function
     RawText s -> ()
@@ -1328,3 +1444,28 @@ let rec print_main_result_first_page_text path cg_bin_path results_web_path id t
         (List.rev (Xlist.fold paragraphs [] find_prev_next_paragraph)) in
       print_main_result_first_page_paragraph path cg_bin_path results_web_path id tokens prev_next_map (List.hd paragraphs)
   | AltText l -> Xlist.iter l (fun (mode,text) -> print_main_result_first_page_text path cg_bin_path results_web_path id tokens text)
+
+let to_string_eniam_sentence verbosity tokens (result : eniam_parse_result) =
+  let status_string = string_of_status result.status in
+  if result.status = NotParsed then
+    [status_string ^ ": " ^ cat_tokens_sequence result.text_fragments (ENIAM_LCGchart.select_maximal result.chart1)]
+  else [status_string]
+
+let rec to_string_sentence verbosity tokens = function
+    RawSentence s -> []
+  | StructSentence(paths,last) -> []
+  | DepSentence paths -> []
+  | ENIAMSentence result -> to_string_eniam_sentence verbosity tokens result
+  | QuotedSentences sentences -> List.flatten (Xlist.map sentences (fun p -> to_string_sentence verbosity tokens p.sentence))
+  | AltSentence l -> List.flatten (Xlist.map l (fun (mode,sentence) -> to_string_sentence verbosity tokens sentence))
+
+let rec to_string_paragraph verbosity tokens = function
+    RawParagraph s -> []
+  | StructParagraph sentences -> List.flatten (Xlist.map sentences (fun p -> to_string_sentence verbosity tokens p.sentence))
+  | AltParagraph l -> List.flatten (Xlist.map l (fun (mode,paragraph) -> to_string_paragraph verbosity tokens paragraph))
+  | ErrorParagraph s -> ["SubsyntaxError"]
+
+let rec to_string_text verbosity tokens = function
+    RawText s -> []
+  | StructText paragraphs -> List.flatten (Xlist.map paragraphs (to_string_paragraph verbosity tokens))
+  | AltText l -> List.flatten (Xlist.map l (fun (mode,text) -> to_string_text verbosity tokens text))
@@ -112,7 +112,7 @@ let rec main_loop sub_in sub_out in_chan out_chan =
   if text = "" then () else (
     let text,tokens,lex_sems,msg =
       if !lexSemantics_built_in then
-        let text,tokens,msg = ENIAMsubsyntax.catch_parse_text text in
+        let text,tokens,msg = ENIAMsubsyntax.catch_parse_text true text in
         let text,msg =
           if msg <> "" || not !perform_integration then text,msg else
           ENIAMpreIntegration.catch_parse_text ENIAMsubsyntaxTypes.Struct tokens text in
@@ -30,7 +30,7 @@ let load_cats_map filename =
   | l -> failwith ("load_cats_map: " ^ String.concat "\t" l))
  
 let cats_map = load_cats_map ENIAM_LCGlexiconTypes.user_cats_filename
-let proj_map = load_cats_map ENIAM_LCGlexiconTypes.user_proj_filename
+let coerced_map = load_cats_map ENIAM_LCGlexiconTypes.user_coerced_filename
  
 let subsyntax_built_in = ref true
 let subsyntax_host = ref "localhost"
@@ -96,19 +96,19 @@ let get_cats cats_map = function
   | Proper(_,_,_,cats) -> if cats = [] then ["X"] else cats
   | _ -> ["X"]
  
-let expand_projections proj_map cats =
-  Xlist.rev_map cats (fun cat -> cat, cat :: (try StringMap.find proj_map cat with Not_found -> []))
+let expand_coercions coerced_map cats =
+  Xlist.rev_map cats (fun cat -> cat, cat :: (try StringMap.find coerced_map cat with Not_found -> []))
 (*  StringSet.to_list (Xlist.fold cats StringSet.empty (fun set cat ->
-    let cats = try StringMap.find proj_map cat with Not_found -> [] in
+    let cats = try StringMap.find coerced_map cat with Not_found -> [] in
     Xlist.fold (cat :: cats) set StringSet.add))*)
  
-let assign_lex_sems proj_map cats_map tokens =
+let assign_lex_sems coerced_map cats_map tokens =
   let lex_sems = ExtArray.make (ExtArray.size tokens) ENIAMlexSemanticsTypes.empty_lex_sem in
   let _ = ExtArray.add lex_sems ENIAMlexSemanticsTypes.empty_lex_sem in
   Int.iter 1 (ExtArray.size tokens - 1) (fun i ->
     let lemma = ENIAMtokens.get_lemma (ExtArray.get tokens i).token in
     let pos = ENIAMtokens.get_pos (ExtArray.get tokens i).token in
-    let cats = expand_projections proj_map (get_cats cats_map (ExtArray.get tokens i).token) in
+    let cats = expand_coercions coerced_map (get_cats cats_map (ExtArray.get tokens i).token) in
     let frames =
         Xlist.rev_map (ENIAMvalence.get_aroles [] lemma pos) (fun (sel,arole,arole_attr,arev) ->
           {ENIAMlexSemanticsTypes.empty_frame with ENIAMlexSemanticsTypes.selectors=sel; ENIAMlexSemanticsTypes.arole=arole; ENIAMlexSemanticsTypes.arole_attr=arole_attr; ENIAMlexSemanticsTypes.arev=arev}) in
@@ -125,7 +125,7 @@ let rec main_loop sub_in sub_out =
       Printf.fprintf sub_out "%s\n\n%!" text;
       (Marshal.from_channel sub_in : ENIAMsubsyntaxTypes.text * token_env ExtArray.t * string)) in
     if msg <> "" then print_endline msg else (
-    let lex_sems = assign_lex_sems proj_map cats_map tokens in
+    let lex_sems = assign_lex_sems coerced_map cats_map tokens in
     let text = ENIAMexec.translate_text text in
     (* let text = ENIAMexec.parse !timeout !verbosity rules tokens lex_sems text in *)
     let text = ENIAMexec.parse !timeout !verbosity rules dep_rules tokens lex_sems text in
@@ -339,6 +339,7 @@ let rec parse_paragraph mode tokens = function
       let l = Xlist.rev_map l (fun (mode,paragraph) ->
         mode, parse_paragraph mode tokens paragraph) in
       AltParagraph(List.rev l)
+  | ErrorParagraph s -> ErrorParagraph s
  
 let rec parse_text mode tokens = function
     RawText s -> RawText s
@@ -37,7 +37,7 @@ let simplify_position_verb mode l = function (* FIXME: dodać czyszczenie E Pro 
   | E Or -> l
   | E (CP(CompTypeUndef,CompUndef)) -> l
   | E (PrepNP(_,prep,Case case)) -> l
-  | E (PrepNCP(prep,Case case,CompTypeUndef,CompUndef)) -> l
+  | E (PrepNCP(_,prep,Case case,CompTypeUndef,CompUndef)) -> l
   | NP(Case "gen") as t -> if mode = "temp" then l else t :: l
   | NP(Case "acc") as t -> if mode = "dur" then l else t :: l
   | t -> t :: l
@@ -253,19 +253,19 @@ let simplify_schemata lexemes pos pos2 lemma schemata =
               "{" ^ String.concat ";" (PhraseSet.fold morfs [] (fun l m -> ENIAMwalStringOf.phrase m :: l)) ^ "}")))); *)
       schemata
  
-let add_adjuncts preps compreps compars pos2 (selectors,cat,schema) =
+let add_adjuncts preps compreps compars pos2 (selectors,cat,(*has_context,*)schema) =
   let compreps = Xlist.rev_map compreps ENIAMwalRenderer.render_comprep in
   let prepnps = Xlist.rev_map preps (fun (prep,cases) -> ENIAMwalRenderer.render_prepnp prep cases) in
   let prepadjps = Xlist.rev_map preps (fun (prep,cases) -> ENIAMwalRenderer.render_prepadjp prep cases) in
   let compars = Xlist.rev_map compars ENIAMwalRenderer.render_compar in
   match pos2 with
-    "verb" -> [selectors,cat,schema @ ENIAMwalRenderer.verb_adjuncts_simp @ prepnps @ prepadjps @ compreps @ compars]
+    "verb" -> [selectors,cat,(*has_context,*)schema @ ENIAMwalRenderer.verb_adjuncts_simp @ prepnps @ prepadjps @ compreps @ compars]
   | "noun" -> [
-      [Nsyn,Eq,["proper"]] @ selectors,cat,ENIAMwalRenderer.proper_noun_adjuncts_simp @ prepnps @ compreps @ compars;
-      [Nsyn,Eq,["common"];Nsem,Eq,["measure"]] @ selectors,cat,ENIAMwalRenderer.measure_noun_adjuncts_simp @ prepnps @ compreps @ compars;
-      [Nsyn,Eq,["common"];Nsem,Neq,["measure"]] @ selectors,cat,ENIAMwalRenderer.common_noun_adjuncts_simp @ prepnps @ compreps @ compars]
-  | "adj" -> [selectors,cat,schema @ ENIAMwalRenderer.adj_adjuncts_simp @ compars]
-  | "adv" -> [selectors,cat,schema @ ENIAMwalRenderer.adv_adjuncts_simp @ compars]
+      [Nsyn,Eq,["proper"]] @ selectors,cat,(*has_context,*)ENIAMwalRenderer.proper_noun_adjuncts_simp @ prepnps @ compreps @ compars;
+      [Nsyn,Eq,["common"];Nsem,Eq,["measure"]] @ selectors,cat,(*has_context,*)ENIAMwalRenderer.measure_noun_adjuncts_simp @ prepnps @ compreps @ compars;
+      [Nsyn,Eq,["common"];Nsem,Neq,["measure"]] @ selectors,cat,(*has_context,*)ENIAMwalRenderer.common_noun_adjuncts_simp @ prepnps @ compreps @ compars]
+  | "adj" -> [selectors,cat,(*has_context,*)schema @ ENIAMwalRenderer.adj_adjuncts_simp @ compars]
+  | "adv" -> [selectors,cat,(*has_context,*)schema @ ENIAMwalRenderer.adv_adjuncts_simp @ compars]
   | _ -> []
  
 open ENIAMlexSemanticsTypes
@@ -23,20 +23,22 @@ open ENIAMlexSemanticsTypes
 open ENIAMwalTypes
 open Xstd
  
-let find_meaning m =
+(*let snode_values = ENIAM_LCGlexiconTypes.SelectorMap.find ENIAMcategoriesPL.selector_values ENIAM_LCGlexiconTypes.SNode*)
+
+let find_sense m =
   try
-    ENIAMplWordnet.find_meaning m.plwnluid
+    ENIAMplWordnet.find_sense m.plwnluid
   with Not_found ->
-    m.name ^ "-" ^ m.variant, [], unknown_meaning_weight
+    m.name ^ "-" ^ m.variant, [], unknown_sense_weight
  
-let find_prep_meaning lemma hipero =
+let find_prep_sense lemma hipero =
   let hipero = match hipero with
       [Predef hipero] -> hipero
-    | _ -> failwith "find_prep_meaning" in
-  if hipero = "ALL" then lemma, [hipero,0], unknown_meaning_weight else
+    | _ -> failwith "find_prep_sense" in
+  if hipero = "ALL" then lemma, [hipero,0], unknown_sense_weight else
   let syn_id = StringMap.find !ENIAMplWordnet.predef hipero in
   let hipero = IntMap.fold (ENIAMplWordnet.get_hipero syn_id) [] (fun hipero syn_id cost -> (ENIAMplWordnet.synset_name syn_id, cost) :: hipero) in
-  lemma, hipero, unknown_meaning_weight
+  lemma, hipero, unknown_sense_weight
  
 let lex_sie = LCG (ENIAMwalRenderer.render_morf (SimpleLexArg("się",QUB)))
  
@@ -47,7 +49,7 @@ let rec has_lemma_sie = function
 (* FIXME: naiwnie wierzymy, że jeśli leksem jest opisany semantycznie w walentym to zawiera ramy dla wszystkich sensów *)
 let find_senses t s =
   (*let set = Xlist.fold s.frames StringSet.empty (fun set frame ->
-    Xlist.fold frame.meanings set (fun set (name,hipero,weight) ->
+    Xlist.fold frame.senses set (fun set (name,hipero,weight) ->
       StringSet.add set name)) in*)
   let senses = match t.token with
       Lemma(lemma,pos,_) -> ENIAMplWordnet.find_senses lemma pos
@@ -62,15 +64,15 @@ let find_senses t s =
     | _ -> [] in
 (*  let senses_sie = Xlist.fold senses_sie [] (fun senses_sie (name,hipero,weight) ->
     if StringSet.mem set name then senses_sie else (name,hipero,weight) :: senses_sie) in
-  let frames = if senses = [] then s.frames else {empty_frame with meanings=senses} :: s.frames in
-  let frames = if senses_sie = [] then frames else {empty_frame with meanings=senses_sie;
+  let frames = if senses = [] then s.frames else {empty_frame with senses=senses} :: s.frames in
+  let frames = if senses_sie = [] then frames else {empty_frame with senses=senses_sie;
     positions=[{empty_position with role="Lemma"; mode=["lemma"]; morfs=[lex_sie]; is_necessary=Req}]} :: frames in*) (* FIXME: czy to nie usuwa elementów z ramy? *)
   let frames = Xlist.rev_map s.frames (fun f ->
-    if f.meanings <> [] then f else
+    if f.senses <> [] then f else
     if has_lemma_sie f.positions then
-      if senses_sie = [] then {f with meanings=[ENIAMtokens.get_lemma t.token ^ " się", [], unknown_meaning_weight]} else {f with meanings=senses_sie}
+      if senses_sie = [] then {f with senses=[ENIAMtokens.get_lemma t.token ^ " się", [], unknown_sense_weight]} else {f with senses=senses_sie}
     else
-      if senses = [] then {f with meanings=[ENIAMtokens.get_lemma t.token, [], unknown_meaning_weight]} else {f with meanings=senses}) in
+      if senses = [] then {f with senses=[ENIAMtokens.get_lemma t.token, [], unknown_sense_weight]} else {f with senses=senses}) in
   {s with frames=frames}
  
 let find_selprefs schema = (* FIXME: RelationRole *)
@@ -124,6 +126,7 @@ let rec split_tokens_into_groups_paragraph a = function
       Xlist.iter sentences (fun p -> split_tokens_into_groups_sentence a p.sentence)
   | AltParagraph l -> Xlist.iter l (fun (mode,paragraph) ->
       split_tokens_into_groups_paragraph a paragraph)
+  | ErrorParagraph s -> ()
  
 let rec split_tokens_into_groups_text a = function
     RawText s -> ()
@@ -172,10 +175,10 @@ let semantize lemma pos (selectors,schema) =
  
 let load_num_sem filename (num_sem,num_sem_args) =
   File.fold_tab filename (num_sem,num_sem_args) (fun (num_sem,num_sem_args) -> function
-      [lemma;_;nsems;meaning;sem_args] ->
+      [lemma;_;nsems;sense;sem_args] ->
         let sem_args = Xstring.split "," sem_args in
         Xlist.fold (Xstring.split "," nsems) num_sem (fun num_sem nsem ->
-          StringMap.add_inc num_sem lemma [nsem,meaning] (fun l -> (nsem,meaning) ::l)),
+          StringMap.add_inc num_sem lemma [nsem,sense] (fun l -> (nsem,sense) ::l)),
         StringMap.add_inc num_sem_args lemma sem_args  (fun _ -> failwith "load_num_sem")
     | _ -> failwith "load_num_sem")
  
@@ -208,13 +211,13 @@ let mark_nosem frame =
 let assign_prep_semantics lemma =
   if StringSet.mem ENIAMcategoriesPL.compar_lexemes lemma then
     [{empty_frame with
-      meanings = [find_prep_meaning lemma [Predef "ALL"]];
+      senses = [find_prep_sense lemma [Predef "ALL"]];
       positions= [{empty_position with
         dir=Forward_; gf=CORE;
         morfs=ENIAMwalRenderer.compar_morfs; is_necessary=Req}];
       agf="arg"};
     {empty_frame with
-      meanings = [find_prep_meaning lemma [Predef "ALL"]];
+      senses = [find_prep_sense lemma [Predef "ALL"]];
       positions= [{empty_position with
         sel_prefs=[SynsetName "ALL"]; dir=Forward_; gf=CORE;
         morfs=ENIAMwalRenderer.compar_morfs; is_necessary=Req}];
@@ -223,14 +226,14 @@ let assign_prep_semantics lemma =
   let roles = try StringMap.find ENIAMlexSemanticsData.prep_roles lemma with Not_found -> [] in
   (* Printf.printf "assign_prep_semantics: |roles|=%d\n%!" (Xlist.size roles); *)
   {empty_frame with
-    meanings = [find_prep_meaning lemma [Predef "ALL"]];
+    senses = [find_prep_sense lemma [Predef "ALL"]];
     positions= [{empty_position with
       dir=if lemma="temu" then Backward_ else Forward_; gf=CORE;
       morfs=ENIAMwalRenderer.prep_morfs; is_necessary=Req}];
     agf="arg"} ::
   (if roles = [] then (* FIXME: zaślepka do usunięcia po stworzeniu listy przyimków *)
   [{empty_frame with
-    meanings = [find_prep_meaning lemma [Predef "ALL"]];
+    senses = [find_prep_sense lemma [Predef "ALL"]];
     positions= [{empty_position with
       sel_prefs=[SynsetName "ALL"]; dir=if lemma="temu" then Backward_ else Forward_; gf=CORE;
       morfs=ENIAMwalRenderer.prep_morfs; is_necessary=Req}];
@@ -238,28 +241,28 @@ let assign_prep_semantics lemma =
   else
   Xlist.map roles (function (case,arole,arole_attr,hipero,sel_prefs) ->
     (* Printf.printf "assign_prep_semantics: case=%s arole=%s arole_attr=%s\n%!" case arole arole_attr; *)
-    let meaning = find_prep_meaning lemma hipero in (* FIXME: zaślepka dla meaning i weight *)
+    let sense = find_prep_sense lemma hipero in (* FIXME: zaślepka dla sense i weight *)
     (* print_endline "assign_prep_semantics 1"; *)
     let positions = [{empty_position with
       sel_prefs=sel_prefs; dir=if lemma="temu" then Backward_ else Forward_; gf=CORE;
       morfs=ENIAMwalRenderer.prep_morfs(*ENIAMwalRenderer.assing_prep_morfs (lemma,case)*); is_necessary=Req}] in
     (* print_endline "assign_prep_semantics 2"; *)
-    {empty_frame with selectors=[ENIAM_LCGlexiconTypes.Case,ENIAM_LCGlexiconTypes.Eq,[case]]; meanings=[meaning]; positions=find_selprefs positions;
+    {empty_frame with selectors=[ENIAM_LCGlexiconTypes.Case,ENIAM_LCGlexiconTypes.Eq,[case]]; senses=[sense]; positions=find_selprefs positions;
      arole=arole; arole_attr=arole_attr; arev=false; agf="adjunct"}))
  
 let assign_num_semantics lemma =
   let sems = try StringMap.find !num_sem lemma with Not_found -> [] in
-  Xlist.map sems (fun (nsem,meaning) ->
-    let meaning,arole_attr =
-      if meaning = "" then (lemma, [], unknown_meaning_weight),"Approximate"
-      else (meaning, [], unknown_meaning_weight),"Exact" in
+  Xlist.map sems (fun (nsem,sense) ->
+    let sense,arole_attr =
+      if sense = "" then (lemma, [], unknown_sense_weight),"Approximate"
+      else (sense, [], unknown_sense_weight),"Exact" in
     let arole = match nsem with
           "count" -> "Count"
         | "mass" -> "Measure"
         | _ -> failwith "assign_num_semantics" in
     {empty_frame with
       selectors=[ENIAM_LCGlexiconTypes.Nsem,ENIAM_LCGlexiconTypes.Eq,[nsem]];
-      meanings=[meaning]; arole=arole; arole_attr=arole_attr; arev=false})
+      senses=[sense]; arole=arole; arole_attr=arole_attr; arev=false})
  
 let assign_symb_num_semantics lemma pos =
   let arole_attr = match pos with
@@ -270,14 +273,14 @@ let assign_symb_num_semantics lemma pos =
         | _ -> failwith "assign_symb_num_semantics" in
   [{empty_frame with
       selectors=[ENIAM_LCGlexiconTypes.Nsem,ENIAM_LCGlexiconTypes.Eq,["count"]];
-      meanings=[lemma, [], unknown_meaning_weight]; arole="Count"; arole_attr=arole_attr; arev=false}]
+      senses=[lemma, [], unknown_sense_weight]; arole="Count"; arole_attr=arole_attr; arev=false}]
  
 (*let set_context lemma pos frame =
   if pos = "fin" || pos = "praet" || pos = "winien" || pos = "inf" || pos = "pred" || pos = "impt" || pos = "imps" || pos = "ger" || pos = "pcon" || pos = "pant" then
     [{frame with has_context=true}] else
   if pos = "subst" then
-    if frame.meanings = [] then failwith "set_context" else
-    let Xlist.fold frame.meanings (fun -> ) in
+    if frame.senses = [] then failwith "set_context" else
+    let Xlist.fold frame.senses (fun -> ) in
   else [{frame with has_context=true}](*wydarzenie 1 czynność 1*)  (*czynności 1 czyn 1*)*)
  
 let assign_valence tokens lex_sems group =
@@ -302,17 +305,17 @@ let assign_valence tokens lex_sems group =
       let schemata = ENIAMadjuncts.simplify_schemata lexemes pos pos2 lemma schemata1 in
       (* Printf.printf "C %s |schemata|=%d\n" lemma (Xlist.size schemata); *)
       let schemata = Xlist.rev_map schemata (fun (selectors,schema) ->
-          selectors,["X",["X"]],ENIAMwalRenderer.render_simple_schema schema) in
+          selectors,["X",["X"]],(*snode_values,*)ENIAMwalRenderer.render_simple_schema schema) in
       let schemata = List.flatten (Xlist.rev_map schemata (ENIAMadjuncts.add_adjuncts preps compreps compars pos2)) in
-      let schemata = if schemata = [] then [[],["X",["X"]],[]] else schemata in
+      let schemata = if schemata = [] then [[],["X",["X"]],(*snode_values,*)[]] else schemata in
       (* Printf.printf "D %s |schemata|=%d\n" lemma (Xlist.size schemata); *)
       let entries = List.flatten (Xlist.rev_map entries (ENIAMvalence.transform_lex_entry pos lemma)) in
       let entries = Xlist.map entries (fun (selectors,entry) ->
           selectors,ENIAMwalRenderer.render_lex_entry entry) in
-      let connected = List.flatten (Xlist.map connected (fun (sopinion,fopinion,meanings,neg,pred,aspect,schema1) ->
+      let connected = List.flatten (Xlist.map connected (fun (sopinion,fopinion,senses,neg,pred,aspect,schema1) ->
           List.flatten (Xlist.rev_map (ENIAMvalence.transform_entry pos lemma neg pred aspect schema1) (fun (selectors,schema) ->
               Xlist.rev_map (ENIAMvalence.get_aroles schema1 lemma pos) (fun (sel,arole,arole_attr,arev) ->
-                  {selectors=sel @ selectors; meanings=Xlist.map meanings find_meaning; positions=schema;
+                  {empty_frame with selectors=sel @ selectors; senses=Xlist.map senses find_sense; positions=schema;
                    arole=arole; arole_attr=arole_attr; arev=arev; agf=""; rev_hipero=false; sem_args=[]; sopinion=sopinion; fopinion=fopinion}))))) in
       (* Printf.printf "E %s |connected|=%d\n" lemma (Xlist.size connected); *)
       let connected = if connected = [] then List.flatten (Xlist.rev_map (make_unique schemata1) (semantize lemma pos)) else connected in
@@ -344,7 +347,7 @@ let assign_valence tokens lex_sems group =
       let connected = Xlist.rev_map connected mark_nosem in
       let connected = if connected = [] then semantize lemma pos ([],[]) else connected in
       let connected = Xlist.rev_map connected (fun f ->
-        if f.meanings = [] then {f with meanings=[lemma, ["X",1], unknown_meaning_weight]} else f) in
+        if f.senses = [] then {f with senses=[lemma, ["X",1], unknown_sense_weight]} else f) in
       (* let connected = List.flatten (Xlist.rev_map connected (set_context lemma pos)) in *)
       (* Printf.printf "K %s |connected|=%d\n" lemma (Xlist.size connected); *)
       ExtArray.set lex_sems id {(*(ExtArray.get lex_sems id) with*)
@@ -404,11 +407,11 @@ let disambiguate_senses lex_sems group =
   Xlist.iter group (fun id ->
     let t = ExtArray.get lex_sems id in
     ExtArray.set lex_sems id {t with frames=Xlist.map t.frames (fun frame ->
-      let meanings = Xlist.map frame.meanings (fun (name,hipero,weight) ->
+      let senses = Xlist.map frame.senses (fun (name,hipero,weight) ->
         let hipero = Xlist.fold hipero ["ALL",0] (fun hipero (name,cost) ->
           if StringSet.mem prefs name then (name,cost) :: hipero else hipero) in
         name,hipero,weight) in
-      {frame with meanings=meanings})})
+      {frame with senses=senses})})
  
 let remove_unused_tokens tokens groups =
   let set = Xlist.fold groups IntSet.empty (fun set group ->
@@ -459,9 +462,9 @@ let rec create_tokens_for_artificial_nodes_rec tokens lex_sems = function
     Node t ->
         let t = if t.id = 0 then (
           let id = ExtArray.add tokens empty_token_env in
-          let lex_sem = {empty_lex_sem with frames=[{empty_frame with meanings=[t.lemma, [t.lemma,0], unknown_meaning_weight]}]} in
+          let lex_sem = {empty_lex_sem with frames=[{empty_frame with senses=[t.lemma, [t.lemma,0], unknown_sense_weight]}]} in
           let id2 = ExtArray.add lex_sems lex_sem in
-          if id <>id2 then failwith "create_tokens_for_artificial_nodes_rec" else
+          if id <> id2 then failwith "create_tokens_for_artificial_nodes_rec: tokens inconsistent with lex_sems" else
           let t = if t.symbol = Dot then
             {t with symbol = match t.pos with
                 "<root>" -> Tuple[Val "<root>"]
@@ -239,7 +239,7 @@ let qub_roles = Xlist.fold [
   ] StringMap.empty (fun map (k,r,a) -> StringMap.add_inc map k [r,a] (fun l -> (r,a) :: l))
  
  
-let prep_roles = Xlist.fold [ (* lemma,case,role,role_attr,meaning/hipero,sel_prefs *)
+let prep_roles = Xlist.fold [ (* lemma,case,role,role_attr,sense/hipero,sel_prefs *)
   "od","gen",		"Location","Source",["POŁOŻENIE"],["POŁOŻENIE"];
   "spod","gen",		"Location","Source",["POŁOŻENIE"],["POŁOŻENIE"];
   "spomiędzy","gen",	"Location","Source",["POŁOŻENIE"],["POŁOŻENIE"];
@@ -60,14 +60,15 @@ let html_of_lex_sems tokens lex_sems =
     let core = Printf.sprintf "%3d %s %s" id orth lemma  in
     let lex_entries = Xlist.map t.lex_entries (fun (selectors,s) ->
         "&emsp;&emsp;[" ^ ENIAMcategoriesPL.string_of_selectors selectors ^ "] " ^ ENIAM_LCGstringOf.grammar_symbol 0 s) in
-    let schemata = Xlist.map t.schemata (fun (selectors,cat,l) ->
+    let schemata = Xlist.map t.schemata (fun (selectors,cat,(*snode,*)l) ->
         "&emsp;&emsp;[" ^ ENIAMcategoriesPL.string_of_selectors selectors ^ "]" ^
         String.concat "," (Xlist.map cat (fun (m,l) -> m ^ "[" ^ String.concat "," l ^ "]")) ^
+        (*String.concat "|" snode ^*)
         " {" ^ String.concat ", " (Xlist.map l (fun (d,s) ->
             ENIAM_LCGstringOf.direction d ^ ENIAM_LCGstringOf.grammar_symbol 0 s)) ^ "}") in
-    (* let frames = Xlist.map t.frames (fun (selectors,meanings,schema) -> FIXME
+    (* let frames = Xlist.map t.frames (fun (selectors,senses,schema) -> FIXME
         "&emsp;&emsp;[" ^ ENIAMcategoriesPL.string_of_selectors selectors ^ "] {" ^ ENIAMwalStringOf.schema schema ^ "} " ^
-        String.concat ", " (Xlist.map meanings (fun m -> ENIAMwalStringOf.meaning m))) in *)
+        String.concat ", " (Xlist.map senses (fun m -> ENIAMwalStringOf.sense m))) in *)
     (String.concat "<br>\n    " ([core] @ schemata (*@ frames*) @ lex_entries)) :: l))) ^
   "</P>"
  
@@ -76,7 +77,7 @@ let html_of_lex_sems tokens lex_sems =
   lex_entries: ((ENIAM_LCGlexiconTypes.selector * ENIAM_LCGlexiconTypes.selector_relation * string list) list *
                 ENIAM_LCGtypes.grammar_symbol) list;
   frames: ((ENIAM_LCGlexiconTypes.selector * ENIAM_LCGlexiconTypes.selector_relation * string list) list *
-             ENIAMwalTypes.meaning list * ENIAMwalTypes.position list) list;*)
+             ENIAMwalTypes.sense list * ENIAMwalTypes.position list) list;*)
  
 let text_and_tokens_and_lex_sems text tokens lex_sems msg =
   if msg = "" then sprintf "%s\n%s<BR>\n%s<BR>\n%s<BR>\n%s\n" html_header
@@ -40,13 +40,14 @@ let string_of_lex_sems tokens lex_sems =
     let core = Printf.sprintf "%3d %s %s" id orth lemma  in
     let lex_entries = Xlist.map t.lex_entries (fun (selectors,s) ->
         "&[" ^ ENIAMcategoriesPL.string_of_selectors selectors ^ "] " ^ ENIAM_LCGstringOf.grammar_symbol 0 s) in
-    let schemata = Xlist.map t.schemata (fun (selectors,cat,l) ->
+    let schemata = Xlist.map t.schemata (fun (selectors,cat,(*snode,*)l) ->
         "[" ^ ENIAMcategoriesPL.string_of_selectors selectors ^ "]" ^
         String.concat "," (Xlist.map cat (fun (m,l) -> m ^ "[" ^ String.concat "," l ^ "]")) ^
+        (*String.concat "|" snode ^*)
         " {" ^ String.concat "," (Xlist.map l (fun (d,s) ->
             ENIAM_LCGstringOf.direction d ^ ENIAM_LCGstringOf.grammar_symbol 0 s)) ^ "}") in
     let frames = Xlist.map t.frames (fun f ->
         "*" ^ arole f ^ "[" ^ ENIAMcategoriesPL.string_of_selectors f.selectors ^ "] {" ^ ENIAMwalStringOf.schema f.positions ^ "} " ^
-        String.concat "," (Xlist.map f.meanings (fun (sense,hipero,weight) ->
+        String.concat "," (Xlist.map f.senses (fun (sense,hipero,weight) ->
         Printf.sprintf "%s[%s]%.2f" sense (String.concat "," (Xlist.map hipero (fun (s,n) -> s ^ " " ^ string_of_int n))) weight))) in
     (String.concat "\n    " ([core] @ schemata @ frames @ lex_entries)) :: l)))
@@ -22,7 +22,8 @@ open Xstd
  
 type frame = {
   selectors: (ENIAM_LCGlexiconTypes.selector * ENIAM_LCGlexiconTypes.selector_relation * string list) list;
-  meanings: ((*ENIAMwalTypes.meaning **) string * (string * int) list * float) list;
+  senses: ((*ENIAMwalTypes.sense **) string * (string * int) list * float) list;
+  cats: (string * string list) list;
   positions: ENIAMwalTypes.position list;
   arole: string;
   arole_attr: string;
@@ -30,17 +31,18 @@ type frame = {
   agf: string;
   sem_args: string list;
   rev_hipero: bool;
-  (* has_context: bool; *)
+  (*snode: string list;*)
   sopinion: ENIAMwalTypes.opinion;
   fopinion: ENIAMwalTypes.opinion;
   }
  
-let empty_frame = {selectors=[]; meanings=[]; positions=[]; arole=""; arole_attr=""; arev=false; agf=""; sem_args=[]; rev_hipero=false; (*has_context=false;*)
+let empty_frame = {selectors=[]; senses=[]; cats=["X",["X"]]; positions=[]; arole=""; arole_attr=""; arev=false; agf=""; sem_args=[]; rev_hipero=false; (*snode=[];*)
   sopinion=ENIAMwalTypes.Nieokreslony; fopinion=ENIAMwalTypes.Nieokreslony}
  
 type lex_sem = {
   schemata: ((ENIAM_LCGlexiconTypes.selector * ENIAM_LCGlexiconTypes.selector_relation * string list) list *
              (string * string list) list * (* sensy *)
+             (*string list **) (* has_context *)
              (ENIAM_LCGtypes.direction * ENIAM_LCGtypes.grammar_symbol) list) list;
   lex_entries: ((ENIAM_LCGlexiconTypes.selector * ENIAM_LCGlexiconTypes.selector_relation * string list) list *
                 ENIAM_LCGtypes.grammar_symbol) list;
@@ -49,10 +51,10 @@ type lex_sem = {
   }
  
 let empty_lex_sem = {
-  schemata=[]; lex_entries=[]; frames=[]; (*cats=["X",["X"]]*)}
+  schemata=[]; lex_entries=[]; frames=[]}
  
 let hipero_threshold = 3
-let unknown_meaning_weight = -1.
+let unknown_sense_weight = -1.
  
 let lu_filename = resource_path ^ "/plWordnet/lu.tab"
 let ex_hipo_filename = resource_path ^ "/plWordnet/ex_hipo.tab"
@@ -61,5 +63,5 @@ let syn_filename = resource_path ^ &quot;/plWordnet/syn.tab&quot;
 let predef_filename = resource_path ^ "/lexSemantics/predef_prefs.tab"
 let proper_classes_filename = resource_path ^ "/lexSemantics/proper_classes.tab"
  
-let proj_filename = ENIAMwalTypes.data_path ^ "/projections.tab"
-let proper_meanings_filename = ENIAMwalTypes.data_path ^ "/proper_meanings.tab"
+let coercions_filename = ENIAMwalTypes.data_path ^ "/coercions.tab"
+let proper_cats_filename = ENIAMwalTypes.data_path ^ "/proper_cats.tab"
@@ -155,7 +155,7 @@ let find_proper_senses senses =
   List.flatten (Xlist.rev_map senses (fun sense ->
     try StringMap.find !proper_classes sense with Not_found -> failwith ("find_proper_senses: " ^ sense)))
  
-let find_meaning lu_id =
+let find_sense lu_id =
   let lemma,variant,syn_id = IntMap.find !lu_names lu_id in
   lemma ^ "-" ^ variant,
   IntMap.fold (get_hipero syn_id) [] (fun hipero syn_id cost -> (synset_name syn_id, cost) :: hipero),
@@ -56,6 +56,7 @@ let transform_gdy = function
   | "imperative" -> [Comp "gdy"]
   | "conditional" -> [Comp "gdyby"]
   | "gerundial" -> [Comp "gdy"]
+  | "no-subj" -> [Comp "gdy"]
   | "" -> [Comp "gdy";Comp "gdyby"]
   | s -> failwith ("transform_gdy: " ^ s)
  
@@ -232,9 +233,29 @@ let transform_qub_phrase lemma = function
   | phrase -> failwith ("transform_qub_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase)
  
 let transform_qub_pos lemma = function
-    | QUB as morf -> [morf]
+  | QUB as morf -> [morf]
   | pos -> failwith ("transform_qub_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos)
  
+let transform_interj_phrase lemma = function
+    NP(Case "nom") as morf -> [morf]
+  | Null -> [Null]
+  | phrase -> failwith ("transform_interj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase)
+
+let transform_interj_pos lemma = function
+  | pos -> failwith ("transform_interj_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos)
+
+let transform_sinterj_phrase lemma = function
+  | phrase -> failwith ("transform_sinterj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase)
+
+let transform_sinterj_pos lemma = function
+  | pos -> failwith ("transform_sinterj_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos)
+
+let transform_aglt_phrase lemma = function
+  | phrase -> failwith ("transform_aglt_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase)
+
+let transform_aglt_pos lemma = function
+  | pos -> failwith ("transform_aglt_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos)
+
 let transform_siebie_phrase lemma = function
   | phrase -> failwith ("transform_siebie_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase)
  
@@ -243,9 +264,9 @@ let transform_siebie_pos lemma = function
   | pos -> failwith ("transform_siebie_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos)
  
 let transform_pers_subj_phrase lemma negation mood = function (* FIXME: prepnp(na,loc) *)
-  | NP(Str) -> [NP(NomAgr)(*;NumP(NomAgr)*)]
+  | NP(Str) -> [NP(NomAgr);NP(VocAgr)(*;NumP(NomAgr)*)]
   | NP(Part) -> [NP(Case "gen");NP(Case "acc")(*;NumP(Case "gen");NumP(Case "acc")*)] (* tylko w 'nalewać', 'nalać', 'ponalewać', 'najechać','uzbierać' *)
-  | NCP(Str,ctype,comp) -> [NCP(NomAgr,ctype,comp)]
+  | NCP(Str,ctype,comp) -> [NCP(NomAgr,ctype,comp);NCP(VocAgr,ctype,comp)]
   | CP(ctype,comp) as morf -> [morf]
   | InfP _ as morf -> [morf]
   | Or as morf -> [morf]
@@ -265,7 +286,7 @@ let transform_pers_subj_pos lemma negation mood = function
 let transform_ger_subj_phrase lemma negation mood control = function
   | NP(Str) -> [NP(Case "gen");PrepNP(Pnosem,"przez",Case "acc")(*;NumP(Case "gen")*)(*;PrepNumP("przez",Case "acc")*)] (* FIXME: czy przez:acc jest możliwe? *)
   | NP(Part) -> [NP(Case "gen")(*;NP(Case "acc")*)(*;NumP(Case "gen");NumP(Case "acc")*)]
-  | NCP(Str,ctype,comp) -> [NCP(Case "gen",ctype,comp);PrepNCP("przez",Case "acc",ctype,comp)] (* FIXME: czy przez:acc jest możliwe? *)
+  | NCP(Str,ctype,comp) -> [NCP(Case "gen",ctype,comp);PrepNCP(Pnosem,"przez",Case "acc",ctype,comp)] (* FIXME: czy przez:acc jest możliwe? *)
   | CP(ctype,comp) as morf -> [morf]
   | InfP _ as morf -> [morf] (* FIXME: czy to jest możliwe? *)
   | Or as morf -> [morf]
@@ -284,7 +305,7 @@ let transform_ger_subj_pos lemma negation mood = function (* FIXME: ADV(_) *)
  
 let transform_ppas_subj_phrase lemma negation mood control = function
   | NP(Str) -> [PrepNP(Pnosem,"przez",Case "acc")(*;PrepNumP("przez",Case "acc")*)]
-  | NCP(Str,ctype,comp) -> [PrepNCP("przez",Case "acc",ctype,comp)]
+  | NCP(Str,ctype,comp) -> [PrepNCP(Pnosem,"przez",Case "acc",ctype,comp)]
   | CP(ctype,comp) as morf -> [morf]
   | Pro -> if control then [Pro] else [Null]
   | morf -> failwith ("transform_ppas_subj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf)
@@ -300,6 +321,7 @@ let transform_pers_phrase lemma negation mood = function
   | AdjP(Str) -> Xlist.map (transform_str mood negation) (fun case -> AdjP case) (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
   | AdjP CaseAgr as morf -> if mood = "gerundial" then [AdjP AllAgr] else (failwith ("transform_pers_phrase2: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf))
   | AdjP(Case _) as morf -> [morf] (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
+  | AdjP(NomAgr) as morf -> if mood = "no-subj" then [AdjP(Case "nom")] else [morf]
   | CP(ctype,comp) as morf -> [morf]
   | PrepNP _ as morf -> [morf]
   | PrepAdjP _ as morf -> [morf] (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
@@ -348,7 +370,7 @@ let transform_pers_pos lemma negation mood = function
 let rec transform_comps negation mood = function
   | CP(ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> CP(ctype,comp))
   | NCP(case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> NCP(case,ctype,comp))
-  | PrepNCP(prep,case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> PrepNCP(prep,case,ctype,comp))
+  | PrepNCP(psem,prep,case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> PrepNCP(psem,prep,case,ctype,comp))
   | E phrase -> Xlist.map (transform_comps negation mood phrase) (fun phrase -> E phrase)
   | morf -> [morf]
  
@@ -363,31 +385,31 @@ let transform_preps morf =
       | SimpleLexArg(lex,PREP c) -> if is_compar lex then SimpleLexArg(lex,COMPAR c) else SimpleLexArg(lex,PREP c)
       | PrepNP(psem,prep,c) -> if is_compar prep then ComparP(prep,c) else PrepNP(psem,prep,c)
       | PrepAdjP(prep,c) -> if is_compar prep then ComparP(prep,c) else PrepAdjP(prep,c)
-      | PrepNCP(prep,case,ctype,comp) as morf -> if is_compar prep then failwith "transform_preps" else morf
+      | PrepNCP(psem,prep,case,ctype,comp) as morf -> if is_compar prep then failwith "transform_preps 1" else morf
       | morf -> morf in
   match morf with
     | ComparP(prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst";"postp"] (fun case -> ComparP(prep,Case case))
-    | ComparP _ -> failwith "transform_preps"
+    | ComparP _ -> failwith "transform_preps 2"
     | LexArg(id,lex,COMPAR Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst";"postp"] (fun case -> LexArg(id,lex,COMPAR (Case case)))
     | SimpleLexArg(lex,COMPAR Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst";"postp"] (fun case -> SimpleLexArg(lex,COMPAR (Case case)))
     | LexArg(id,lex,COMPAR (Case _)) as morf -> [morf]
     | SimpleLexArg(lex,COMPAR (Case _)) as morf -> [morf]
-    | LexArg(id,lex,COMPAR _) -> failwith "transform_preps"
-    | SimpleLexArg(lex,COMPAR _) -> failwith "transform_preps"
+    | LexArg(id,lex,COMPAR _) -> failwith "transform_preps 3"
+    | SimpleLexArg(lex,COMPAR _) -> failwith "transform_preps 4"
     | PrepNP(sem,"per",Str) -> [PrepNP(sem,"per",Case "nom");PrepNP(sem,"per",Case "voc")] (* FIXME: voc do poprawienie w leksykonie *)
     | PrepNP(_,_,Case _) as morf -> [morf]
     | PrepAdjP(_,Case _) as morf -> [morf]
-    | PrepNCP(_,Case _,_,_) as morf -> [morf]
-    | PrepNP(_,"_",CaseUndef) as morf -> [morf]
-    | PrepNP _ -> failwith "transform_preps"
-    | PrepAdjP _ -> failwith "transform_preps"
-    | PrepNCP _ -> failwith "transform_preps"
+    | PrepNCP(_,_,Case _,_,_) as morf -> [morf]
+    | PrepNP(_,_,CaseUndef) as morf -> [morf]
+    | PrepNP _ as morf -> failwith ("transform_preps 5: " ^ ENIAMwalStringOf.phrase morf)
+    | PrepAdjP _ -> failwith "transform_preps 6"
+    | PrepNCP _ -> failwith "transform_preps 7"
     | LexArg(id,"w",PREP Str) -> [LexArg(id,"w",PREP (Case "acc"));LexArg(id,"w",PREP (Case "loc"));]
     | SimpleLexArg("w",PREP Str) -> [SimpleLexArg("w",PREP (Case "acc"));SimpleLexArg("w",PREP (Case "loc"))]
     | LexArg(id,lex,PREP (Case _)) as morf -> [morf]
     | SimpleLexArg(lex,PREP (Case _)) as morf -> [morf]
-    | LexArg(id,lex,PREP _) -> failwith "transform_preps"
-    | SimpleLexArg(lex,PREP _) -> failwith "transform_preps"
+    | LexArg(id,lex,PREP _) -> failwith "transform_preps 8"
+    | SimpleLexArg(lex,PREP _) -> failwith "transform_preps 9"
     | morf -> [morf]
  
 let transform_pers_schema lemma negation mood schema =
@@ -445,7 +467,8 @@ let transform_ger_schema lemma negation schema = (* FIXME: zakładam, że ger ze
                     | phrase -> transform_pers_phrase lemma negation "gerundial" phrase))})
  
 let transform_ppas_schema lemma negation mood schema =
-  if not (Xlist.fold schema false (fun b p -> if p.gf = OBJ then true else b)) then raise Not_found else
+  if not (Xlist.fold schema false (fun b p -> if p.gf = OBJ then true else b)) then
+    (*failwith ("transform_ppas_schema: attempt to make ppas schema for lemma " ^ lemma ^ "without OBJ arg")*)raise Not_found else
   Xlist.map schema (fun s ->
         let morfs = List.flatten (Xlist.map s.morfs (transform_comps negation mood)) in
         let morfs = List.flatten (Xlist.map morfs transform_preps) in
@@ -488,6 +511,9 @@ let transform_schema pos lemma schema =
     | "comp" -> transform_comp_phrase,transform_comp_pos
     | "qub" -> transform_qub_phrase,transform_qub_pos
     | "siebie" -> transform_siebie_phrase,transform_siebie_pos
+    | "interj" -> transform_interj_phrase,transform_interj_pos
+    | "sinterj" -> transform_sinterj_phrase,transform_interj_pos
+    | "aglt" -> transform_aglt_phrase,transform_interj_pos
     | _ -> failwith "transform_schema"
   in
   Xlist.map schema (fun s ->
@@ -524,21 +550,26 @@ let aspect_sel = function
 open ENIAM_LCGlexiconTypes
  
 let transform_entry pos lemma negation pred aspect schema =
-  if pos = "subst" || pos = "depr" then (
+  match pos with
+    "subst" |"depr" ->
     if negation <> NegationUndef || pred <> PredFalse || aspect <> AspectUndef then failwith ("transform_entry 1");
-    [[],transform_schema "subst" lemma schema]) else
-  if pos = "adj" || pos = "adjc" || pos = "adjp" then (
+    [[],transform_schema "subst" lemma schema]
+  | "adj" |"adjc" |"adjp" ->
     if negation <> NegationUndef || aspect <> AspectUndef then failwith ("transform_entry 2");
     let sel =  match pred with PredTrue -> [Case,Eq,["pred"]] | _ -> [] in
-    [sel,transform_schema "adj" lemma schema]) else
-  if pos = "adv" || pos = "prep" || pos = "comprep" || pos = "comp" || pos = "compar" || pos = "qub" || pos = "siebie" then (
+    [sel,transform_schema "adj" lemma schema]
+  | "adv" | "prep" | "comprep" | "comp" | "compar" | "qub" | "siebie" ->
     if negation <> NegationUndef || (*pred <> PredFalse ||*) aspect <> AspectUndef then failwith ("transform_entry 3"); (* FIXME: typy przysłówków *)
-    [[],transform_schema pos lemma schema]) else
+    [[],transform_schema pos lemma schema]
+  | _ ->
   if pred <> PredFalse then failwith ("transform_entry 4") else
   if pos = "num" || pos = "intnum" then (
     if negation <> NegationUndef || aspect <> AspectUndef then failwith ("transform_entry 5");
     Xlist.map ["congr";"rec"] (fun acm ->
         [Acm,Eq,[acm]],transform_num_schema acm schema)) else
+  if pos = "interj" then (
+    if negation <> NegationUndef || pred <> PredFalse || aspect <> AspectUndef then failwith ("transform_entry 6");
+    [[],transform_schema "interj" lemma schema]) else
   List.flatten (Xlist.map (expand_negation negation) (fun negation ->
   let sel = [Negation,Eq,[ENIAMwalStringOf.negation negation]] @ aspect_sel aspect in
   if pos = "fin" || pos = "bedzie" then
@@ -555,7 +586,7 @@ let transform_entry pos lemma negation pred aspect schema =
     [sel @ [Mood,Eq,["indicative"]],transform_pers_schema lemma negation "indicative" schema] else
   if pos = "pcon" || pos = "pant" || pos = "inf" || pos = "pact" then
       (* let role,role_attr = try get_role SUBJ schema with Not_found -> "Initiator","" in *)
-    [sel, transform_nosubj_schema lemma negation "indicative" schema] else
+    [sel, transform_nosubj_schema lemma negation "no-subj" schema] else
   if pos = "ppas" then
       try
         (* let role,role_attr = try get_role OBJ schema with Not_found -> "Theme","" in *)
@@ -563,6 +594,7 @@ let transform_entry pos lemma negation pred aspect schema =
       with Not_found -> [] else
   if pos = "ger" then
     [sel,transform_ger_schema lemma negation schema] else
+  if schema = [] then [[],[]] else
   failwith ("transform_entry: " ^ pos)))
  
 let transform_lex_entry pos lemma = function
@@ -256,7 +256,7 @@ let rec parse_phrase = function
   | "comparp",[[Text prep]] -> ComparP(prep,Str)
   | "cp",[ctype;comp] -> CP(parse_ctype ctype,parse_comp comp)
   | "ncp",[case;ctype;comp] -> NCP(parse_case case,parse_ctype ctype,parse_comp comp)
-  | "prepncp",[[Text prep];case;ctype;comp] -> PrepNCP(prep,parse_case case,parse_ctype ctype,parse_comp comp)
+  | "prepncp",[[Text prep];case;ctype;comp] -> PrepNCP(Psem,prep,parse_case case,parse_ctype ctype,parse_comp comp)
   | "infp",[aspect] -> InfP(parse_aspect aspect)
   | "fixed",[[Text lemma]] -> FixedP lemma
   | "fixed",[[Text lemma1];[Text lemma2]] -> FixedP (lemma1 ^ "," ^ lemma2)
@@ -423,43 +423,43 @@ let load_schemata filename =
  
 let load_connected filename =
   let l = File.load_tab filename (function
-        [pos; lemma; sopinion; fopinion; meanings; neg; pred; aspect; schema] ->
-          pos, lemma, sopinion, fopinion, meanings, neg, pred, aspect, schema
+        [pos; lemma; sopinion; fopinion; senses; neg; pred; aspect; schema] ->
+          pos, lemma, sopinion, fopinion, senses, neg, pred, aspect, schema
       | _ -> failwith "load_schemata") in
-  Xlist.fold l Entries.empty (fun entries (pos,lemma,sopinion,fopinion,meanings,neg,pred,aspect,schema) ->
+  Xlist.fold l Entries.empty (fun entries (pos,lemma,sopinion,fopinion,senses,neg,pred,aspect,schema) ->
       let sopinion = parse_opinion sopinion in
       let fopinion = parse_opinion fopinion in
-      let meanings = Xlist.map (Xstring.split "," meanings) int_of_string in
+      let senses = Xlist.map (Xstring.split "," senses) int_of_string in
       let neg = parse_negation [Text neg] in
       let pred = parse_pred pred in
       let aspect = parse_aspect [Text aspect] in
       let schema = parse_connected_schema (split_text schema) in
-      let entry = sopinion,fopinion,meanings,neg,pred,aspect,schema in
+      let entry = sopinion,fopinion,senses,neg,pred,aspect,schema in
       Entries.add_inc entries pos lemma entry)
  
-let load_meanings filename =
+let load_senses filename =
   let l = File.load_tab filename (function
         [id; name; variant; plwnluid; gloss] -> {mng_id=int_of_string id;
                                                  name=name;
                                                  variant=variant;
                                                  plwnluid=int_of_string plwnluid;
                                                  gloss=gloss}
-      | _ -> failwith "load_meaning") in
-  Xlist.fold l IntMap.empty (fun meanings m ->
-      IntMap.add meanings m.mng_id m)
+      | _ -> failwith "load_sense") in
+  Xlist.fold l IntMap.empty (fun senses m ->
+      IntMap.add senses m.mng_id m)
  
 let phrases = ref IntMap.empty
 let entries = ref StringMap.empty
 let schemata = ref StringMap.empty
 let connected = ref StringMap.empty
-let meanings = ref IntMap.empty
+let senses = ref IntMap.empty
  
 let initialize () =
   phrases := load_phrases phrases_filename;
   entries := load_entries entries_filename;
   schemata := load_schemata schemata_filename;
   connected := load_connected connected_filename;
-  meanings := load_meanings meanings_filename;
+  senses := load_senses senses_filename;
   ()
  
  
@@ -23,7 +23,7 @@ open Xstd
 let create_phrase_reqs s (reqs,noreqs) = function
   | PrepNP(_,prep,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | PrepAdjP(prep,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
-  | PrepNCP(prep,_,_,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
+  | PrepNCP(_,prep,_,_,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | ComparP(prep,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | FixedP(prep) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | SimpleLexArg(lex,_) -> StringMap.add_inc reqs s (StringSet.singleton lex) (fun set -> StringSet.add set lex), noreqs
@@ -34,7 +34,7 @@ let create_phrase_reqs s (reqs,noreqs) = function
 let create_phrase_reqs2 s (reqs,noreqs) = function
   | PrepNP(_,prep,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | PrepAdjP(prep,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
-  | PrepNCP(prep,_,_,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
+  | PrepNCP(_,prep,_,_,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | ComparP(prep,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | FixedP(prep) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | SimpleLexArg(lex,_) -> IntMap.add_inc reqs s (StringSet.singleton lex) (fun set -> StringSet.add set lex), noreqs
@@ -90,6 +90,7 @@ let select_comprep_adjuncts lexemes =
              not (StringSet.is_empty (StringSet.intersection reqs lexemes)) then s :: l else l)
       with Not_found -> l)
  
+(* FIXME: trzeba zanalizować interację tej procedury z Pro w schemacie w wersji z walentym i z semantyką dziedzinową *)
 let set_necessary pos schema =
   Xlist.map schema (fun p ->
     let nec =
@@ -101,6 +102,8 @@ let set_necessary pos schema =
         | _ -> b) then Req else
       if p.gf <> SUBJ && p.cr = [] (*&& p.ce = []*) then Opt else
       if p.gf = SUBJ && pos = "impt" then ProNG else
+      if p.gf = SUBJ && pos = "pact" then Opt else
+      if p.gf = OBJ && pos = "ppas" then Opt else
       if Xlist.fold p.morfs false (fun b -> function
           NP NomAgr -> true
         | NCP(NomAgr,_,_) -> true
@@ -126,7 +129,7 @@ let reduce_phrase (test_comprep_reqs,test_comprep_reqs2,test_lexarg_reqs,test_le
   | ComparP(prep,case) as phrase  -> if test_lexemes prep then phrase else raise Not_found
   | CP(ctype,comp) -> CP(ctype,reduce_comp test_lexemes comp)
   | NCP(case,ctype,comp) -> if test_lexemes "to" then NCP(case,ctype,reduce_comp test_lexemes comp) else raise Not_found
-  | PrepNCP(prep,case,ctype,comp) -> if test_lexemes prep && test_lexemes "to" then PrepNCP(prep,case,ctype,reduce_comp test_lexemes comp) else raise Not_found
+  | PrepNCP(psem,prep,case,ctype,comp) -> if test_lexemes prep && test_lexemes "to" then PrepNCP(psem,prep,case,ctype,reduce_comp test_lexemes comp) else raise Not_found
   | SimpleLexArg(lemma,_) as phrase  -> if test_lexemes lemma then phrase else raise Not_found
   | LexArg(id,lemma,_) as phrase  -> if test_lexemes lemma && test_lexarg_reqs id then phrase else raise Not_found
   | FixedP lemma as phrase  -> if test_lexemes lemma then phrase else raise Not_found
@@ -168,11 +171,11 @@ let merge_entries phrases entries =
   Entries.map entries (fun _ _ (opinion,neg,pred,aspect,schema) ->
       opinion,neg,pred,aspect,merge_schema phrases schema)
  
-let merge_entries_conn phrases meanings entries =
-  Entries.map entries (fun _ _ (sopinion,fopinion,meaning_ids,neg,pred,aspect,schema) ->
-      let meanings = Xlist.map meaning_ids (fun id ->
-          try IntMap.find meanings id with Not_found -> failwith "merge_entries_conn") in
-      sopinion,fopinion,meanings,neg,pred,aspect,merge_schema phrases schema)
+let merge_entries_conn phrases senses entries =
+  Entries.map entries (fun _ _ (sopinion,fopinion,sense_ids,neg,pred,aspect,schema) ->
+      let senses = Xlist.map sense_ids (fun id ->
+          try IntMap.find senses id with Not_found -> failwith "merge_entries_conn") in
+      sopinion,fopinion,senses,neg,pred,aspect,merge_schema phrases schema)
  
 let create_tests comprep_reqs comprep_reqs2 lexarg_reqs lexemes =
   let lexemes = StringSet.add (StringSet.add lexemes "_") "" in
@@ -191,7 +194,7 @@ let create_tests comprep_reqs comprep_reqs2 lexarg_reqs lexemes =
   StringSet.mem lexemes
  
  
-let select_entries_full phrases entries schemata connected meanings comprep_reqs comprep_reqs2 lexarg_reqs lexemes =
+let select_entries_full phrases entries schemata connected senses comprep_reqs comprep_reqs2 lexarg_reqs lexemes =
   let tests = create_tests comprep_reqs comprep_reqs2 lexarg_reqs lexemes in
   let entries = reduce_entries lexemes entries in
   let schemata = reduce_entries lexemes schemata in
@@ -205,25 +208,25 @@ let select_entries_full phrases entries schemata connected meanings comprep_reqs
     with ImpossibleSchema -> []) in
   let schemata = Entries.map schemata (fun _ _ (opinion,neg,pred,aspect,schema) ->
       opinion,neg,pred,aspect,reduce_schema2 tests schema) in
-  let connected = merge_entries_conn phrases meanings connected in
-  let connected = Entries.map connected (fun _ _ (sopinion,fopinion,meaning_ids,neg,pred,aspect,schema) ->
-      sopinion,fopinion,meaning_ids,neg,pred,aspect,reduce_schema2 tests schema) in
+  let connected = merge_entries_conn phrases senses connected in
+  let connected = Entries.map connected (fun _ _ (sopinion,fopinion,sense_ids,neg,pred,aspect,schema) ->
+      sopinion,fopinion,sense_ids,neg,pred,aspect,reduce_schema2 tests schema) in
   entries,schemata,connected
  
-let select_all_entries phrases entries schemata connected meanings =
+let select_all_entries phrases entries schemata connected senses =
   let schemata = merge_entries phrases schemata in
-  let connected = merge_entries_conn phrases meanings connected in
+  let connected = merge_entries_conn phrases senses connected in
   entries,schemata,connected
  
 let select_entries lexemes =
   select_entries_full !ENIAMwalParser.phrases !ENIAMwalParser.entries !ENIAMwalParser.schemata
-    !ENIAMwalParser.connected !ENIAMwalParser.meanings !comprep_reqs !comprep_reqs2 !lexarg_reqs lexemes
+    !ENIAMwalParser.connected !ENIAMwalParser.senses !comprep_reqs !comprep_reqs2 !lexarg_reqs lexemes
  
 (* let entries,schemata,connected =
   (* let lexemes = StringSet.of_list ["Ala"; "ma"; "kot"] in *)
   let lexemes = StringSet.of_list ["dorastać"; "dorobić"; "po"; "bok"; "na"] in
   select_entries ENIAMwalParser.phrases ENIAMwalParser.entries ENIAMwalParser.schemata
-    ENIAMwalParser.connected ENIAMwalParser.meanings comprep_reqs comprep_reqs2 lexarg_reqs lexemes *)
+    ENIAMwalParser.connected ENIAMwalParser.senses comprep_reqs comprep_reqs2 lexarg_reqs lexemes *)
  
 (* let _ =
   StringMap.iter comprep_reqs (fun s set ->
@@ -53,7 +53,7 @@ let render_pos_entry = function
   | "ppas" ->  [Atom "ppas"; AVar "number"; AVar "case"; AVar "gender"; AVar "negation"]
   | "inf" ->  [Atom "inf"; AVar "aspect"; AVar "negation"]
   | "qub" ->  [Atom "qub"]
-  | "compar" ->  [Atom "compar"; AVar "case"]
+  | "compar" ->  [Atom "comparp"; AVar "case"]
   | "comp" ->  [Atom "comp"; AVar "ctype"]
   | "fin" ->  [Atom "pers"; AVar "negation"]
   | "praet" ->  [Atom "pers"; AVar "negation"]
@@ -117,7 +117,7 @@ let render_phrase = function
     | PrepNP(Psem,prep,Case case) -> Tensor[Atom "prepnp"; Atom "sem"; Atom prep; Atom case]
     | PrepNP(Pnosem,prep,Case case) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Atom case]
     | AdjP(Case case) -> Tensor[Atom "adjp"; Top; Atom case; Top]
-(*      | AdjP NomAgr -> Tensor[Atom "adjp"; AVar "number"; Atom "nom"; AVar "gender"]*)
+    | AdjP NomAgr -> Tensor[Atom "adjp"; AVar "number"; Atom "nom"; AVar "gender"]
     | AdjP AllAgr -> Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]
 (*    | AdjP CaseAgr -> Tensor[Atom "adjp"; Top; AVar "case"; Top]
       | PrepAdjP("",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]*)
@@ -130,7 +130,7 @@ let render_phrase = function
     | PrepNumP(_,prep,Case case) -> Tensor[Atom "prepnump"; Atom prep; Atom case] *)
 (*      | ComprepNP("") -> Tensor[Atom "comprepnp"; Top]*)
     | ComprepNP(prep) -> Tensor[Atom "comprepnp"; Atom prep]
-    | ComparP(prep,Case case) -> Tensor[Atom "compar"; Atom prep; Atom case]
+    | ComparP(prep,Case case) -> Tensor[Atom "comparp"; Atom prep; Atom case]
     (* | ComparPP(_,prep) -> Tensor[Atom "comparpp"; Atom prep] *)
     (* | IP -> Tensor[Atom "ip";Top;Top;Top] *)
     | CP (ctype,Comp comp) -> Tensor[Atom "cp"; arg_of_ctype ctype; Atom comp]
@@ -139,8 +139,10 @@ let render_phrase = function
     | NCP(Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; Top; Top]
     | NCP(NomAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp]
     | NCP(NomAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
-    | PrepNCP(prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
-    | PrepNCP(prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom prep; Atom case; Top; Top]
+    | PrepNCP(Psem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
+    | PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; Top; Top]
+    | PrepNCP(Pnosem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
+    | PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; Top; Top]
     | InfP(Aspect aspect) -> Tensor[Atom "infp"; Atom aspect]
     | InfP AspectUndef -> Tensor[Atom "infp"; Top]
     (* | PadvP -> Tensor[Atom "padvp"] *)
@@ -171,54 +173,64 @@ let render_phrase = function
     | E (PrepNP(Pnosem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Atom case]
     | E (NP(Case case)) -> Tensor[Atom "np"; Top; Atom case; Top; Top]
     | E (NCP(Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; Top; Top]
-    | E (PrepNCP(prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom prep; Atom case; Top; Top]
+    | E (PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; Top; Top]
+    | E (PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; Top; Top]
     | phrase -> failwith ("render_phrase: " ^ ENIAMwalStringOf.phrase phrase)
  
-let render_phrase_cat cat = function
-      NP(Case case) -> Tensor[Atom "np"; Atom cat; Top; Atom case; Top; Top]
-    | NP NomAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
-(*    | NP GenAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "gen"; AVar "gender"; AVar "person"]
-      | NP AllAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]*)
-    | NP CaseAgr -> Tensor[Atom "np"; Atom cat; Top; AVar "case"; Top; Top]
-    | NP CaseUndef -> Tensor[Atom "np"; Atom cat; Top; Top; Top; Top]
-    | PrepNP(Psem,"",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Top; Top]
-    | PrepNP(Psem,"_",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Top; Top]
-    | PrepNP(Psem,prep,Case case) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Atom prep; Atom case]
-    | PrepNP(Pnosem,"",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Top; Top]
-    | PrepNP(Pnosem,"_",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Top; Top]
-    | PrepNP(Pnosem,prep,Case case) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Atom prep; Atom case]
-    | AdjP(Case case) -> Tensor[Atom "adjp"; Atom cat; Top; Atom case; Top]
-(*      | AdjP NomAgr -> Tensor[Atom "adjp"; AVar "number"; Atom "nom"; AVar "gender"]*)
-    | AdjP AllAgr -> Tensor[Atom "adjp"; Atom cat; AVar "number"; AVar "case"; AVar "gender"]
-(*    | AdjP CaseAgr -> Tensor[Atom "adjp"; Top; AVar "case"; Top]
-      | PrepAdjP("",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]*)
-    | PrepAdjP(prep,Case case) -> Tensor[Atom "prepadjp"; Atom cat; Atom prep; Atom case]
-    (* | NumP(Case case) -> Tensor[Atom "nump"; Top; Atom case; Top; Top]
+let render_phrase_cat cat role node = function
+      NP(Case case) -> Tensor[Atom "np"; Top; Atom case; Top; Top; Atom cat; Atom role; Atom node]
+    | NP NomAgr -> Tensor[Atom "np"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Atom cat; Atom role; Atom node]
+    | NP VocAgr -> Tensor[Atom "np"; AVar "number"; Atom "voc"; AVar "gender"; AVar "person"; Atom cat; Atom role; Atom node]
+(*    | NP GenAgr -> Tensor[Atom "np"; AVar "number"; Atom "gen"; AVar "gender"; AVar "person"; Atom cat; Atom role; Atom node]
+      | NP AllAgr -> Tensor[Atom "np"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"; Atom cat; Atom role; Atom node]*)
+    | NP CaseAgr -> Tensor[Atom "np"; Top; AVar "case"; Top; Top; Atom cat; Atom role; Atom node]
+    | NP CaseUndef -> Tensor[Atom "np"; Top; Top; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Psem,"",CaseUndef) -> Tensor[Atom "prepnp"; Atom "sem"; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Psem,"_",CaseUndef) -> Tensor[Atom "prepnp"; Atom "sem"; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Psem,"_",Case case) -> Tensor[Atom "prepnp"; Atom "sem"; Top; Atom case; Atom cat; Atom role; Atom node]
+    | PrepNP(Psem,prep,CaseUndef) -> Tensor[Atom "prepnp"; Atom "sem"; Atom prep; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Psem,prep,Case case) -> Tensor[Atom "prepnp"; Atom "sem"; Atom prep; Atom case; Atom cat; Atom role; Atom node]
+    | PrepNP(Pnosem,"",CaseUndef) -> Tensor[Atom "prepnp"; Atom "nosem"; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Pnosem,"_",CaseUndef) -> Tensor[Atom "prepnp"; Atom "nosem"; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Pnosem,"_",Case case) -> Tensor[Atom "prepnp"; Atom "nosem"; Top; Atom case; Atom cat; Atom role; Atom node]
+    | PrepNP(Pnosem,prep,CaseUndef) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Top; Atom cat; Atom role; Atom node]
+    | PrepNP(Pnosem,prep,Case case) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Atom case; Atom cat; Atom role; Atom node]
+    | AdjP(Case case) -> Tensor[Atom "adjp"; Top; Atom case; Top; Top; Atom cat; Atom role; Atom node]
+    | AdjP NomAgr -> Tensor[Atom "adjp"; AVar "number"; Atom "nom"; AVar "gender"; Top; Atom cat; Atom role; Atom node]
+    | AdjP AllAgr -> Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"; Top; Atom cat; Atom role; Atom node]
+(*    | AdjP CaseAgr -> Tensor[Atom "adjp"; Top; AVar "case"; Top; Top; Atom cat; Atom role; Atom node]
+      | PrepAdjP("",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top; Atom cat; Atom role; Atom node]*)
+    | PrepAdjP(prep,Case case) -> Tensor[Atom "prepadjp"; Atom prep; Atom case; Atom cat; Atom role; Atom node]
+    (* | NumP(Case case) -> Tensor[Atom "nump"; Top; Atom case; Top; Atom node]
     | NumP NomAgr -> Tensor[Atom "nump"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
     | NumP CaseAgr -> Tensor[Atom "nump"; Top; AVar "case"; Top; Top]
     | NumP CaseUndef -> Tensor[Atom "nump"; Top; Top; Top; Top]
     | PrepNumP(_,"",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]
     | PrepNumP(_,prep,Case case) -> Tensor[Atom "prepnump"; Atom prep; Atom case] *)
-(*      | ComprepNP("") -> Tensor[Atom "comprepnp"; Top]*)
-    | ComprepNP(prep) -> Tensor[Atom "comprepnp"; Atom cat; Atom prep]
-    | ComparP(prep,Case case) -> Tensor[Atom "compar"; Atom cat; Atom prep; Atom case]
-    (* | ComparPP(_,prep) -> Tensor[Atom "comparpp"; Atom prep] *)
-    (* | IP -> Tensor[Atom "ip";Top;Top;Top] *)
-    | CP (ctype,Comp comp) -> Tensor[Atom "cp"; Atom cat; arg_of_ctype ctype; Atom comp]
-    (*    | CP (ctype,CompUndef) -> Tensor[Atom "cp"; arg_of_ctype ctype; Top]*)
-    | NCP(Case case,ctype,Comp comp) -> Tensor[Atom "ncp"; Atom cat; Top; Atom case; Top; Top; arg_of_ctype ctype; Atom comp]
-    | NCP(Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Atom cat; Top; Atom case; Top; Top; Top; Top]
-    | NCP(NomAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp]
-    | NCP(NomAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
-    | PrepNCP(prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom cat; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
-    | PrepNCP(prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom cat; Atom prep; Atom case; Top; Top]
-    | InfP(Aspect aspect) -> Tensor[Atom "infp"; Atom cat; Atom aspect]
-    | InfP AspectUndef -> Tensor[Atom "infp"; Atom cat; Top]
-    (* | PadvP -> Tensor[Atom "padvp"] *)
-    | AdvP "misc" -> Tensor[Atom "advp"; Atom cat; Top] (* FIXME: a może Atom "mod" zamiast Top *)
-    | AdvP "" -> Tensor[Atom "advp"; Atom cat; Top] (* FIXME: a może Atom "mod" zamiast Top *)
-    | AdvP mode -> Tensor[Atom "advp"; Atom cat; Atom mode]
-    | ColonP -> Tensor[Atom "colonp"; Atom cat]
+(*      | ComprepNP("") -> Tensor[Atom "comprepnp"; Top; Atom cat; Atom role; Atom node]*)
+    | ComprepNP(prep) -> Tensor[Atom "comprepnp"; Atom prep; Atom cat; Atom role; Atom node]
+    | ComparP(prep,Case case) -> Tensor[Atom "comparp"; Atom prep; Atom case; Atom cat; Atom role; Atom node]
+    (* | ComparPP(_,prep) -> Tensor[Atom "comparpp"; Atom prep; Atom cat; Atom role; Atom node] *)
+    (* | IP -> Tensor[Atom "ip";Top;Top;Top; Atom cat; Atom role; Atom node] *)
+    | CP (ctype,Comp comp) -> Tensor[Atom "cp"; arg_of_ctype ctype; Atom comp; Atom cat; Atom role; Atom node]
+    (*    | CP (ctype,CompUndef) -> Tensor[Atom "cp"; arg_of_ctype ctype; Top; Atom cat; Atom role; Atom node]*)
+    | NCP(Case case,ctype,Comp comp) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; arg_of_ctype ctype; Atom comp; Atom cat; Atom role; Atom node]
+    | NCP(Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; Top; Top; Atom cat; Atom role; Atom node]
+    | NCP(NomAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp; Atom cat; Atom role; Atom node]
+    | NCP(NomAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top; Atom cat; Atom role; Atom node]
+    | NCP(VocAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; AVar "number"; Atom "voc"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp; Atom cat; Atom role; Atom node]
+    | NCP(VocAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; AVar "number"; Atom "voc"; AVar "gender"; AVar "person"; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNCP(Psem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp; Atom cat; Atom role; Atom node]
+    | PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; Top; Top; Atom cat; Atom role; Atom node]
+    | PrepNCP(Pnosem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp; Atom cat; Atom role; Atom node]
+    | PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; Top; Top; Atom cat; Atom role; Atom node]
+    | InfP(Aspect aspect) -> Tensor[Atom "infp"; Atom aspect; Atom cat; Atom role; Atom node]
+    | InfP AspectUndef -> Tensor[Atom "infp"; Top; Atom cat; Atom role; Atom node]
+    (* | PadvP -> Tensor[Atom "padvp"; Atom cat; Atom role; Atom node] *)
+    | AdvP "misc" -> Tensor[Atom "advp"; Top; Atom cat; Atom role; Atom node] (* FIXME: a może Atom "mod" zamiast Top *)
+    | AdvP "" -> Tensor[Atom "advp"; Top; Atom cat; Atom role; Atom node] (* FIXME: a może Atom "mod" zamiast Top *)
+    | AdvP mode -> Tensor[Atom "advp"; Top; Atom cat; Atom role; Atom node]
+    | ColonP -> Tensor[Atom "colonp"; Atom cat; Atom cat; Atom role; Atom node]
     (* | PrepP -> Tensor[Atom "prepp";Top]
     | Prep("",CaseAgr) -> Tensor[Atom "prep"; Top; AVar "case"]
     | Prep("",CaseUAgr) -> Tensor[Atom "prep"; Top; AVar "ucase"]
@@ -233,14 +245,15 @@ let render_phrase_cat cat = function
     | AuxImp -> Tensor[Atom "aux-imp"]
     | Pro -> One
         | ProNG -> One *)
-    | E (CP(CompTypeUndef,CompUndef)) -> Tensor[Atom "cp"; Atom cat; Top; Top]
-    | E (NCP(NomAgr,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
-    | E (NP(NomAgr)) -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
-    | E (PrepNP(Psem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Atom prep; Atom case]
-    | E (PrepNP(Pnosem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Atom prep; Atom case]
-    | E (NP(Case case)) -> Tensor[Atom "np"; Atom cat; Top; Atom case; Top; Top]
-    | E (NCP(Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Atom cat; Top; Atom case; Top; Top; Top; Top]
-    | E (PrepNCP(prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom cat; Atom prep; Atom case; Top; Top]
+    | E (CP(CompTypeUndef,CompUndef)) -> Tensor[Atom "cp"; Top; Top; Atom cat; Atom role; Atom node]
+    | E (NCP(NomAgr,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top; Atom cat; Atom role; Atom node]
+    | E (NP(NomAgr)) -> Tensor[Atom "np"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Atom cat; Atom role; Atom node]
+    | E (PrepNP(Psem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom "sem"; Atom prep; Atom case; Atom cat; Atom role; Atom node]
+    | E (PrepNP(Pnosem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Atom case; Atom cat; Atom role; Atom node]
+    | E (NP(Case case)) -> Tensor[Atom "np"; Top; Atom case; Top; Top; Atom cat; Atom role; Atom node]
+    | E (NCP(Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; Top; Top; Atom cat; Atom role; Atom node]
+    | E (PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; Top; Top; Atom cat; Atom role; Atom node]
+    | E (PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; Top; Top; Atom cat; Atom role; Atom node]
     | phrase -> failwith ("render_phrase_cat: " ^ ENIAMwalStringOf.phrase phrase)
  
 let render_morf = function
@@ -251,7 +264,7 @@ let render_morf = function
     | SimpleLexArg(lex,pos) -> Tensor([Atom "lex";Atom lex] @ render_pos pos)
     | phrase -> render_phrase phrase
  
-let render_morf_cat cats = function
+let render_morf_cat cats role node = function
     | Null -> [One]
     | Pro -> [One]
     | ProNG -> [One]
@@ -261,13 +274,13 @@ let render_morf_cat cats = function
     (* | X -> Tensor[Atom "X"]
        | Lex lex -> Tensor[Atom lex] *)
     | LexArg(id,lex,pos) -> [Tensor([Atom "lex";Atom (string_of_int id);Atom lex] @ render_pos pos)]
-    | SimpleLexArg(lex,pos) -> [Tensor([Atom "lex";Atom lex] @ render_pos pos)]
-    | phrase -> Xlist.map cats (fun cat -> render_phrase_cat cat phrase)
+    | SimpleLexArg(lex,pos) -> [Tensor([Atom "lex";Atom lex] @ render_pos pos @ [Atom role; Atom node])]
+    | phrase -> Xlist.map cats (fun cat -> render_phrase_cat cat role node phrase)
  
-let extract_sel_prefs sel_prefs =
+(* let extract_sel_prefs sel_prefs =
   Xlist.map sel_prefs (function
       SynsetName s -> s
-    | _ -> failwith "extract_sel_prefs")
+    | _ -> failwith "extract_sel_prefs") *)
  
 let render_schema schema =
   Xlist.map schema (fun p ->
@@ -283,7 +296,7 @@ let translate_dir = function
  
 let render_schema_cat schema =
   Xlist.map schema (fun p ->
-      match List.flatten (Xlist.map p.morfs (render_morf_cat (extract_sel_prefs p.sel_prefs))) with
+      match List.flatten (Xlist.map p.morfs (render_morf_cat p.cat_prefs p.role p.node)) with
         [] -> failwith "render_schema"
       | [s] -> translate_dir p.dir,s
       | l -> translate_dir p.dir,Plus l)
@@ -298,7 +311,8 @@ let render_connected_schema schema =
  
 let render_connected_schema_cat schema =
   Xlist.map schema (fun p ->
-      {p with morfs=Xlist.map (List.flatten (Xlist.map p.morfs (render_morf_cat (extract_sel_prefs p.sel_prefs)))) (fun morf -> LCG morf)})
+      {p with
+        morfs=Xlist.map (List.flatten (Xlist.map p.morfs (render_morf_cat p.cat_prefs p.role p.node))) (fun morf -> LCG morf)})
  
 (* FIXME: tu trzeba by dodać zwykłe reguły dla czasowników dotyczące ich negacji, aglutynatu itp. *)
 let render_lex_entry = function
@@ -353,9 +367,9 @@ let render_connected_prepadjp prep cases =
   adjunct (postp @ (Xlist.map cases (fun case ->
       Tensor[Atom "prepadjp"; Atom prep; Atom case])))
  
-let render_compar prep = Both,Plus[One;Tensor[Atom "compar"; Atom prep; Top]]
+let render_compar prep = Both,Plus[One;Tensor[Atom "comparp"; Atom prep; Top]]
  
-let render_connected_compar prep = adjunct [Tensor[Atom "compar"; Atom prep; Top]]
+let render_connected_compar prep = adjunct [Tensor[Atom "comparp"; Atom prep; Top]]
  
 let verb_adjuncts_simp = [
   Both, Plus[One;Tensor[Atom "advp"; Atom "pron"]];
+(*
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
+ *
+ *  This library is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *)
+
+open ENIAM_LCGtypes
+open ENIAMwalTypes
+
+let arg_of_ctype = function
+    Int -> Atom "int"
+  | Rel -> Atom "rel"
+  (* | Sub -> LCGtypes.Atom "sub"
+  | Coord -> LCGtypes.Atom "coord" *)
+  | CompTypeUndef -> Top
+  (* | CompTypeAgr -> LCGtypes.AVar "ctype" *)
+
+let render_number = function
+    Number n -> Atom n
+  | NumberUndef -> Top
+  | NumberAgr -> Top
+
+let render_negation = function
+    Negation -> Atom "neg"
+  | Aff -> Atom "aff"
+  | NegationUndef -> Top
+
+let render_pos_entry = function
+    "subst" ->  [Atom "subst"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]
+  | "ppron12" ->  [Atom "ppron12"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]
+  | "ppron3" ->  [Atom "ppron3"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]
+  | "siebie" ->  [Atom "siebie"; AVar "case"]
+  | "num" -> [Atom "num"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]
+  | "intnum" -> [Atom "num"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]
+  | "prep" ->  [Atom "prep"; AVar "case"]
+  | "adj" -> [Atom "adj"; AVar "number"; AVar "case"; AVar "gender"; AVar "grad"]
+  | "adv" -> [Atom "adv"; AVar "grad"]
+  | "ger" ->  [Atom "ger"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"; AVar "negation"]
+  | "pact" ->  [Atom "pact"; AVar "number"; AVar "case"; AVar "gender"; AVar "negation"]
+  | "ppas" ->  [Atom "ppas"; AVar "number"; AVar "case"; AVar "gender"; AVar "negation"]
+  | "inf" ->  [Atom "inf"; AVar "aspect"; AVar "negation"]
+  | "qub" ->  [Atom "qub"]
+  | "compar" ->  [Atom "compar"; AVar "case"]
+  | "comp" ->  [Atom "comp"; AVar "ctype"]
+  | "fin" ->  [Atom "pers"; AVar "negation"]
+  | "praet" ->  [Atom "pers"; AVar "negation"]
+  | "pred" ->  [Atom "pers"; AVar "negation"]
+  | "winien" ->  [Atom "pers"; AVar "negation"]
+  | "bedzie" ->  [Atom "pers"; AVar "negation"]
+  | s -> failwith ("render_pos_entry: " ^ s)
+
+let render_pos = function (* wprowadzam uzgodnienia a nie wartości cech, bo wartości cech są wprowadzane przez leksem a uzgodnienia wiążą je z wartościami u nadrzędnika *)
+  | SUBST(number,Case case) -> [Atom "subst"; render_number number; Atom case; Top; Top]
+  | SUBST(_,NomAgr) -> [Atom "subst"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+  | SUBST(_,GenAgr) -> [Atom "subst"; AVar "number"; Atom "gen"; AVar "gender"; AVar "person"]
+  | SUBST(_,AllAgr) -> [Atom "subst"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]
+  | SUBST(number,CaseAgr) -> [Atom "subst"; render_number number; AVar "case"; Top; Top]
+  | SUBST(_,CaseUndef) -> [Atom "subst"; Top; Top; Top; Top]
+  | PPRON12(number,Case case) -> [Atom "ppron12"; render_number number; Atom case; Top; Top]
+  | PPRON3(number,Case case) -> [Atom "ppron3"; render_number number; Atom case; Top; Top]
+  | SIEBIE(Case case) -> [Atom "siebie"; Atom case]
+  | NUM(Case case,_) -> [Atom "num"; Top; Atom case; Top; Top]
+  | NUM(NomAgr,_) -> [Atom "num"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+(*  | NUM(CaseAgr,_) -> [Atom "num"; Top; AVar "case"; Top; Top]
+    | NUM(CaseUndef,_) -> [Atom "num"; Top; Top; Top; Top]*)
+  | PREP(Case case) -> [Atom "prep"; Atom case]
+  | ADJ(_,Case case,_,Grad grad) -> [Atom "adj"; Top; Atom case; Top; Atom grad]
+(*  | ADJ(_,NomAgr,_,_) -> [Atom "adj"; AVar "number"; Atom "nom"; AVar "gender"]
+    | ADJ(_,CaseAgr,_,_) -> [Atom "adj"; Top; AVar "case"; Top]*)
+  | ADJ(_,CaseUndef,_,Grad grad) -> [Atom "adj"; Top; Top; Top; Atom grad]
+  | ADJ(_,AllAgr,_,Grad grad) -> [Atom "adj"; AVar "number"; AVar "case"; AVar "gender"; Atom grad]
+  | ADJ(_,AllAgr,_,GradUndef) -> [Atom "adj"; AVar "number"; AVar "case"; AVar "gender"; Top]
+  | ADV (Grad grad) -> [Atom "adv"; Atom grad]
+  | ADV GradUndef -> [Atom "adv"; Top]
+  | GER(_,Case case,_,_,neg) -> [Atom "ger"; Top; Atom case; Top; Top; render_negation neg]
+(*  | GER(_,NomAgr,_,_,_) -> [Atom "ger"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+  | GER(_,CaseAgr,_,_,_) -> [Atom "ger"; Top; AVar "case"; Top; Top]
+  | GER(_,CaseUndef,_,_,_) -> [Atom "ger"; Top; Top; Top; Top]
+  | PACT(_,Case case,_,_,_) -> [Atom "pact"; Top; Atom case; Top]
+    | PACT(_,NomAgr,_,_,_) -> [Atom "pact"; AVar "number"; Atom "nom"; AVar "gender"]*)
+  | PACT(_,AllAgr,_,_,neg) -> [Atom "pact"; AVar "number"; AVar "case"; AVar "gender"; render_negation neg]
+(*    | PACT(_,CaseAgr,_,_,_) -> [Atom "pact"; Top; AVar "case"; Top]*)
+  | PPAS(_,Case case,_,_,neg) -> [Atom "ppas"; Top; Atom case; Top; render_negation neg]
+  | PPAS(_,CaseUndef,_,_,neg) -> [Atom "ppas"; Top; Top; Top; render_negation neg]
+  (*  | PPAS(_,NomAgr,_,_,_) -> [Atom "ppas"; AVar "number"; Atom "nom"; AVar "gender"]*)
+  | PPAS(_,AllAgr,_,_,neg) -> [Atom "ppas"; AVar "number"; AVar "case"; AVar "gender"; render_negation neg]
+(*    | PPAS(_,CaseAgr,_,_,_) -> [Atom "ppas"; Top; AVar "case"; Top]*)
+  | INF(Aspect aspect,neg) -> [Atom "inf"; Atom aspect; render_negation neg]
+  | INF(AspectUndef,neg) -> [Atom "inf"; Top; render_negation neg]
+  | QUB -> [Atom "qub"]
+  | COMPAR (Case case) -> [Atom "compar"; Atom case]
+  | COMP ctype -> [Atom "comp"; arg_of_ctype ctype]
+  | PERS neg -> [Atom "pers"; render_negation neg]
+  | pos -> failwith ("render_pos: " ^ ENIAMwalStringOf.pos pos)
+
+let render_phrase = function
+      NP(Case case) -> Tensor[Atom "np"; Top; Atom case; Top; Top]
+    | NP NomAgr -> Tensor[Atom "np"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+(*    | NP GenAgr -> Tensor[Atom "np"; AVar "number"; Atom "gen"; AVar "gender"; AVar "person"]
+      | NP AllAgr -> Tensor[Atom "np"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]*)
+    | NP CaseAgr -> Tensor[Atom "np"; Top; AVar "case"; Top; Top]
+(*    | NP CaseUndef -> Tensor[Atom "np"; Top; Top; Top; Top]
+        | PrepNP("",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]*)
+    | PrepNP(Psem,prep,Case case) -> Tensor[Atom "prepnp"; Atom "sem"; Atom prep; Atom case]
+    | PrepNP(Pnosem,prep,Case case) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Atom case]
+    | AdjP(Case case) -> Tensor[Atom "adjp"; Top; Atom case; Top]
+    | AdjP NomAgr -> Tensor[Atom "adjp"; AVar "number"; Atom "nom"; AVar "gender"]
+    | AdjP AllAgr -> Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]
+(*    | AdjP CaseAgr -> Tensor[Atom "adjp"; Top; AVar "case"; Top]
+      | PrepAdjP("",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]*)
+    | PrepAdjP(prep,Case case) -> Tensor[Atom "prepadjp"; Atom prep; Atom case]
+    (* | NumP(Case case) -> Tensor[Atom "nump"; Top; Atom case; Top; Top]
+    | NumP NomAgr -> Tensor[Atom "nump"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+    | NumP CaseAgr -> Tensor[Atom "nump"; Top; AVar "case"; Top; Top]
+    | NumP CaseUndef -> Tensor[Atom "nump"; Top; Top; Top; Top]
+    | PrepNumP(_,"",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]
+    | PrepNumP(_,prep,Case case) -> Tensor[Atom "prepnump"; Atom prep; Atom case] *)
+(*      | ComprepNP("") -> Tensor[Atom "comprepnp"; Top]*)
+    | ComprepNP(prep) -> Tensor[Atom "comprepnp"; Atom prep]
+    | ComparP(prep,Case case) -> Tensor[Atom "compar"; Atom prep; Atom case]
+    (* | ComparPP(_,prep) -> Tensor[Atom "comparpp"; Atom prep] *)
+    (* | IP -> Tensor[Atom "ip";Top;Top;Top] *)
+    | CP (ctype,Comp comp) -> Tensor[Atom "cp"; arg_of_ctype ctype; Atom comp]
+    (*    | CP (ctype,CompUndef) -> Tensor[Atom "cp"; arg_of_ctype ctype; Top]*)
+    | NCP(Case case,ctype,Comp comp) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; arg_of_ctype ctype; Atom comp]
+    | NCP(Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; Top; Top]
+    | NCP(NomAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp]
+    | NCP(NomAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
+    | PrepNCP(Psem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
+    | PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; Top; Top]
+    | PrepNCP(Pnosem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
+    | PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; Top; Top]
+    | InfP(Aspect aspect) -> Tensor[Atom "infp"; Atom aspect]
+    | InfP AspectUndef -> Tensor[Atom "infp"; Top]
+    (* | PadvP -> Tensor[Atom "padvp"] *)
+    | AdvP "misc" -> Tensor[Atom "advp"; Top] (* FIXME: a może Atom "mod" zamiast Top *)
+    | AdvP mode -> Tensor[Atom "advp"; Atom mode]
+    | ColonP -> Tensor[Atom "colonp"]
+    | FixedP lex -> Tensor[Atom "fixed"; Atom lex]
+    (* | PrepP -> Tensor[Atom "prepp";Top]
+    | Prep("",CaseAgr) -> Tensor[Atom "prep"; Top; AVar "case"]
+    | Prep("",CaseUAgr) -> Tensor[Atom "prep"; Top; AVar "ucase"]
+    | Num(AllAgr,Acm acm) -> Tensor[Atom "num"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"; Atom acm]
+    | Measure(AllUAgr) -> Tensor[Atom "measure"; AVar "unumber"; AVar "ucase"; AVar "ugender"; AVar "uperson"] *)
+    | Or -> Tensor[Atom "or"]
+            (*    | Qub -> Tensor[Atom "qub"]*)
+    (* | Inclusion -> Tensor[Atom "inclusion"]
+    | Adja -> Tensor[Atom "adja"]
+    | Aglt -> Tensor[Atom "aglt"; AVar "number"; AVar "person"]
+    | AuxPast -> Tensor[Atom "aux-past"; AVar "number"; AVar "gender"; AVar "person"]
+    | AuxFut -> Tensor[Atom "aux-fut"; AVar "number"; AVar "gender"; AVar "person"]
+    | AuxImp -> Tensor[Atom "aux-imp"]
+    | Pro -> One
+        | ProNG -> One *)
+    | E Or -> Tensor[Atom "or"]
+    | E (CP(CompTypeUndef,CompUndef)) -> Tensor[Atom "cp"; Top; Top]
+    | E (NCP(NomAgr,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
+    | E (NP(NomAgr)) -> Tensor[Atom "np"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+    | E (PrepNP(Psem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom "sem"; Atom prep; Atom case]
+    | E (PrepNP(Pnosem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom "nosem"; Atom prep; Atom case]
+    | E (NP(Case case)) -> Tensor[Atom "np"; Top; Atom case; Top; Top]
+    | E (NCP(Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Top; Atom case; Top; Top; Top; Top]
+    | E (PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom "sem"; Atom prep; Atom case; Top; Top]
+    | E (PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom "nosem"; Atom prep; Atom case; Top; Top]
+    | phrase -> failwith ("render_phrase: " ^ ENIAMwalStringOf.phrase phrase)
+
+let render_phrase_cat cat = function
+      NP(Case case) -> Tensor[Atom "np"; Atom cat; Top; Atom case; Top; Top]
+    | NP NomAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+    | NP VocAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "voc"; AVar "gender"; AVar "person"]
+(*    | NP GenAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "gen"; AVar "gender"; AVar "person"]
+      | NP AllAgr -> Tensor[Atom "np"; Atom cat; AVar "number"; AVar "case"; AVar "gender"; AVar "person"]*)
+    | NP CaseAgr -> Tensor[Atom "np"; Atom cat; Top; AVar "case"; Top; Top]
+    | NP CaseUndef -> Tensor[Atom "np"; Atom cat; Top; Top; Top; Top]
+    | PrepNP(Psem,"",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Top; Top]
+    | PrepNP(Psem,"_",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Top; Top]
+    | PrepNP(Psem,"_",Case case) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Top; Atom case]
+    | PrepNP(Psem,prep,CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Atom prep; Top]
+    | PrepNP(Psem,prep,Case case) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Atom prep; Atom case]
+    | PrepNP(Pnosem,"",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Top; Top]
+    | PrepNP(Pnosem,"_",CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Top; Top]
+    | PrepNP(Pnosem,"_",Case case) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Top; Atom case]
+    | PrepNP(Pnosem,prep,CaseUndef) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Atom prep; Top]
+    | PrepNP(Pnosem,prep,Case case) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Atom prep; Atom case]
+    | AdjP(Case case) -> Tensor[Atom "adjp"; Atom cat; Top; Atom case; Top]
+    | AdjP NomAgr -> Tensor[Atom "adjp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"]
+    | AdjP AllAgr -> Tensor[Atom "adjp"; Atom cat; AVar "number"; AVar "case"; AVar "gender"]
+(*    | AdjP CaseAgr -> Tensor[Atom "adjp"; Top; AVar "case"; Top]
+      | PrepAdjP("",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]*)
+    | PrepAdjP(prep,Case case) -> Tensor[Atom "prepadjp"; Atom cat; Atom prep; Atom case]
+    (* | NumP(Case case) -> Tensor[Atom "nump"; Top; Atom case; Top; Top]
+    | NumP NomAgr -> Tensor[Atom "nump"; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+    | NumP CaseAgr -> Tensor[Atom "nump"; Top; AVar "case"; Top; Top]
+    | NumP CaseUndef -> Tensor[Atom "nump"; Top; Top; Top; Top]
+    | PrepNumP(_,"",CaseUndef) -> Tensor[Atom "prepnp"; Top; Top]
+    | PrepNumP(_,prep,Case case) -> Tensor[Atom "prepnump"; Atom prep; Atom case] *)
+(*      | ComprepNP("") -> Tensor[Atom "comprepnp"; Top]*)
+    | ComprepNP(prep) -> Tensor[Atom "comprepnp"; Atom cat; Atom prep]
+    | ComparP(prep,Case case) -> Tensor[Atom "compar"; Atom cat; Atom prep; Atom case]
+    (* | ComparPP(_,prep) -> Tensor[Atom "comparpp"; Atom prep] *)
+    (* | IP -> Tensor[Atom "ip";Top;Top;Top] *)
+    | CP (ctype,Comp comp) -> Tensor[Atom "cp"; Atom cat; arg_of_ctype ctype; Atom comp]
+    (*    | CP (ctype,CompUndef) -> Tensor[Atom "cp"; arg_of_ctype ctype; Top]*)
+    | NCP(Case case,ctype,Comp comp) -> Tensor[Atom "ncp"; Atom cat; Top; Atom case; Top; Top; arg_of_ctype ctype; Atom comp]
+    | NCP(Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Atom cat; Top; Atom case; Top; Top; Top; Top]
+    | NCP(NomAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp]
+    | NCP(NomAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
+    | NCP(VocAgr,ctype,Comp comp) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "voc"; AVar "gender"; AVar "person"; arg_of_ctype ctype; Atom comp]
+    | NCP(VocAgr,CompTypeUndef,CompUndef) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "voc"; AVar "gender"; AVar "person"; Top; Top]
+    | PrepNCP(Psem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom cat; Atom "sem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
+    | PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom cat; Atom "sem"; Atom prep; Atom case; Top; Top]
+    | PrepNCP(Pnosem,prep,Case case,ctype,Comp comp) -> Tensor[Atom "prepncp"; Atom cat; Atom "nosem"; Atom prep; Atom case; arg_of_ctype ctype; Atom comp]
+    | PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef) -> Tensor[Atom "prepncp"; Atom cat; Atom "nosem"; Atom prep; Atom case; Top; Top]
+    | InfP(Aspect aspect) -> Tensor[Atom "infp"; Atom cat; Atom aspect]
+    | InfP AspectUndef -> Tensor[Atom "infp"; Atom cat; Top]
+    (* | PadvP -> Tensor[Atom "padvp"] *)
+    | AdvP "misc" -> Tensor[Atom "advp"; Atom cat; Top] (* FIXME: a może Atom "mod" zamiast Top *)
+    | AdvP "" -> Tensor[Atom "advp"; Atom cat; Top] (* FIXME: a może Atom "mod" zamiast Top *)
+    | AdvP mode -> Tensor[Atom "advp"; Atom cat; Atom mode]
+    | ColonP -> Tensor[Atom "colonp"; Atom cat]
+    (* | PrepP -> Tensor[Atom "prepp";Top]
+    | Prep("",CaseAgr) -> Tensor[Atom "prep"; Top; AVar "case"]
+    | Prep("",CaseUAgr) -> Tensor[Atom "prep"; Top; AVar "ucase"]
+    | Num(AllAgr,Acm acm) -> Tensor[Atom "num"; AVar "number"; AVar "case"; AVar "gender"; AVar "person"; Atom acm]
+    | Measure(AllUAgr) -> Tensor[Atom "measure"; AVar "unumber"; AVar "ucase"; AVar "ugender"; AVar "uperson"] *)
+            (*    | Qub -> Tensor[Atom "qub"]*)
+    (* | Inclusion -> Tensor[Atom "inclusion"]
+    | Adja -> Tensor[Atom "adja"]
+    | Aglt -> Tensor[Atom "aglt"; AVar "number"; AVar "person"]
+    | AuxPast -> Tensor[Atom "aux-past"; AVar "number"; AVar "gender"; AVar "person"]
+    | AuxFut -> Tensor[Atom "aux-fut"; AVar "number"; AVar "gender"; AVar "person"]
+    | AuxImp -> Tensor[Atom "aux-imp"]
+    | Pro -> One
+        | ProNG -> One *)
+    | E (CP(CompTypeUndef,CompUndef)) -> Tensor[Atom "cp"; Atom cat; Top; Top]
+    | E (NCP(NomAgr,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"; Top; Top]
+    | E (NP(NomAgr)) -> Tensor[Atom "np"; Atom cat; AVar "number"; Atom "nom"; AVar "gender"; AVar "person"]
+    | E (PrepNP(Psem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom cat; Atom "sem"; Atom prep; Atom case]
+    | E (PrepNP(Pnosem,prep,Case case)) -> Tensor[Atom "prepnp"; Atom cat; Atom "nosem"; Atom prep; Atom case]
+    | E (NP(Case case)) -> Tensor[Atom "np"; Atom cat; Top; Atom case; Top; Top]
+    | E (NCP(Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "ncp"; Atom cat; Top; Atom case; Top; Top; Top; Top]
+    | E (PrepNCP(Psem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom cat; Atom "sem"; Atom prep; Atom case; Top; Top]
+    | E (PrepNCP(Pnosem,prep,Case case,CompTypeUndef,CompUndef)) -> Tensor[Atom "prepncp"; Atom cat; Atom "nosem"; Atom prep; Atom case; Top; Top]
+    | phrase -> failwith ("render_phrase_cat: " ^ ENIAMwalStringOf.phrase phrase)
+
+let render_morf = function
+    | Null -> One
+    (* | X -> Tensor[Atom "X"]
+       | Lex lex -> Tensor[Atom lex] *)
+    | LexArg(id,lex,pos) -> Tensor([Atom "lex";Atom (string_of_int id);Atom lex] @ render_pos pos)
+    | SimpleLexArg(lex,pos) -> Tensor([Atom "lex";Atom lex] @ render_pos pos)
+    | phrase -> render_phrase phrase
+
+let render_morf_cat cats = function
+    | Null -> [One]
+    | Pro -> [One]
+    | ProNG -> [One]
+    | FixedP lex -> [Tensor[Atom "fixed"; Atom lex]]
+    | Or -> [Tensor[Atom "or"]]
+    | E Or -> [Tensor[Atom "or"]]
+    (* | X -> Tensor[Atom "X"]
+       | Lex lex -> Tensor[Atom lex] *)
+    | LexArg(id,lex,pos) -> [Tensor([Atom "lex";Atom (string_of_int id);Atom lex] @ render_pos pos)]
+    | SimpleLexArg(lex,pos) -> [Tensor([Atom "lex";Atom lex] @ render_pos pos)]
+    | phrase -> Xlist.map cats (fun cat -> render_phrase_cat cat phrase)
+
+(* let extract_sel_prefs sel_prefs =
+  Xlist.map sel_prefs (function
+      SynsetName s -> s
+    | _ -> failwith "extract_sel_prefs") *)
+
+let render_schema schema =
+  Xlist.map schema (fun p ->
+      match Xlist.map p.morfs render_morf with
+        [] -> failwith "render_schema"
+      | [s] -> Both,s
+      | l -> Both,Plus l)
+
+let translate_dir = function
+    Both_ -> Both
+  | Forward_ -> Forward
+  | Backward_ -> Backward
+
+let render_schema_cat schema =
+  Xlist.map schema (fun p ->
+      match List.flatten (Xlist.map p.morfs (render_morf_cat p.cat_prefs)) with
+        [] -> failwith "render_schema"
+      | [s] -> translate_dir p.dir,s
+      | l -> translate_dir p.dir,Plus l)
+
+let render_simple_schema schema =
+  Xlist.map schema (fun morfs ->
+      Both,Plus(One :: Xlist.map morfs render_morf))
+
+let render_connected_schema schema =
+  Xlist.map schema (fun p ->
+      {p with morfs=Xlist.map p.morfs (fun morf -> LCG (render_morf morf))})
+
+let render_connected_schema_cat schema =
+  Xlist.map schema (fun p ->
+      {p with
+        morfs=Xlist.map (List.flatten (Xlist.map p.morfs (render_morf_cat p.cat_prefs))) (fun morf -> LCG morf)})
+
+(* FIXME: tu trzeba by dodać zwykłe reguły dla czasowników dotyczące ich negacji, aglutynatu itp. *)
+let render_lex_entry = function
+    SimpleLexEntry(lemma,pos) -> Tensor([Atom "lex";Atom lemma] @ render_pos_entry pos)
+  | LexEntry(id,lemma,pos,NoRestr,schema) ->
+    ImpSet(Tensor([Atom "lex";Atom (string_of_int id);Atom lemma] @ render_pos_entry pos),render_schema schema)
+    (*Xlist.map (transform_entry pos lemma NegationUndef PredFalse AspectUndef schema) (fun (sel,schema) ->
+        sel,LexEntry(id,lemma,pos,NoRestr,schema))*)
+  | ComprepNPEntry(prep,NoRestr,schema) -> ImpSet(Tensor[Atom "comprepnp"; Atom prep],render_schema schema)
+    (*Xlist.map (transform_entry "comprep" s NegationUndef PredFalse AspectUndef schema) (fun (sel,schema) ->
+        sel,ComprepNPEntry(s,NoRestr,schema))*)
+  | LexEntry(id,lemma,pos,_,[]) (*as entry*) ->
+    ImpSet(Tensor([Atom "lex";Atom (string_of_int id);Atom lemma] @ render_pos_entry pos),[Both,Tensor[AVar "schema"]])
+  | entry -> failwith ("render_entry:" ^ ENIAMwalStringOf.lex_entry entry)
+
+(* let schemata,entries = ENIAMvalence.prepare_all_valence ENIAMwalParser.phrases ENIAMwalParser.schemata ENIAMwalParser.entries *)
+
+(* let _ =
+  (* Entries.map schemata (fun pos lemma (selectors,schema) ->
+      (* Printf.printf "%s %s %s\n" pos lemma (ENIAMwalStringOf.schema schema); *)
+      render_schema schema) *)
+    Entries.map entries (fun pos lemma (selectors,entry) ->
+        (* Printf.printf "%s %s %s\n" pos lemma (ENIAMwalStringOf.schema schema); *)
+        selectors,render_lex_entry entry) *)
+
+let adjunct morfs = {empty_position with gf=ADJUNCT; is_necessary=Opt; morfs=Xlist.map morfs (fun morf -> LCG morf)}
+let adjunct_multi dir  morfs = {empty_position with gf=ADJUNCT; is_necessary=Multi; dir=dir; morfs=Xlist.map morfs (fun morf -> LCG morf)}
+let adjunct_dir dir morfs = {empty_position with gf=ADJUNCT; is_necessary=Opt; dir=dir; morfs=Xlist.map morfs (fun morf -> LCG morf)}
+let adjunct_ce ce morfs = {empty_position with gf=ADJUNCT; ce=[ce]; is_necessary=Opt; morfs=Xlist.map morfs (fun morf -> LCG morf)}
+
+let render_comprep prep = Both,Plus[One;Tensor[Atom "comprepnp"; Atom prep]]
+
+let render_connected_comprep prep = adjunct [Tensor[Atom "comprepnp"; Atom prep]]
+
+let render_prepnp prep cases =
+  Both,Plus(One :: List.flatten (Xlist.map cases (fun case ->
+      [Tensor[Atom "prepnp"; Atom prep; Atom case];
+       Tensor[Atom "prepncp"; Atom prep; Atom case; Top; Top]])))
+
+let render_connected_prepnp prep cases =
+  adjunct (List.flatten (Xlist.map cases (fun case ->
+      [Tensor[Atom "prepnp"; Atom prep; Atom case];
+       Tensor[Atom "prepncp"; Atom prep; Atom case; Top; Top]])))
+
+let render_prepadjp prep cases =
+  let postp = if prep = "z" || prep = "po" || prep = "na" then [Tensor[Atom "prepadjp"; Atom prep; Atom "postp"]] else [] in
+  Both,Plus(One :: postp @ (Xlist.map cases (fun case ->
+      Tensor[Atom "prepadjp"; Atom prep; Atom case])))
+
+let render_connected_prepadjp prep cases =
+  let postp = if prep = "z" || prep = "po" || prep = "na" then [Tensor[Atom "prepadjp"; Atom prep; Atom "postp"]] else [] in
+  adjunct (postp @ (Xlist.map cases (fun case ->
+      Tensor[Atom "prepadjp"; Atom prep; Atom case])))
+
+let render_compar prep = Both,Plus[One;Tensor[Atom "compar"; Atom prep; Top]]
+
+let render_connected_compar prep = adjunct [Tensor[Atom "compar"; Atom prep; Top]]
+
+let verb_adjuncts_simp = [
+  Both, Plus[One;Tensor[Atom "advp"; Atom "pron"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "locat"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "abl"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "adl"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "perl"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "temp"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "dur"]];
+  Both, Plus[One;Tensor[Atom "advp"; Atom "mod"]];
+  Both, Plus[One;Tensor[Atom "np";Top;Atom "dat"; Top; Top];Tensor[Atom "ncp"; Top; Atom "dat"; Top; Top; Top; Top]];
+  Both, Plus[One;Tensor[Atom "np";Top;Atom "inst"; Top; Top];Tensor[Atom "ncp"; Top; Atom "inst"; Top; Top; Top; Top]];
+  Both, Plus[One;Tensor[Atom "date"];Tensor[Atom "day-lex"];Tensor[Atom "day-month"];Tensor[Atom "day"]];
+  Forward, Plus[One;Tensor[Atom "cp";Top; Top]]; (* FIXME: to powinno być jako ostatnia lista argumentów *)
+  Both, Plus[One;Tensor[Atom "or"]];
+  Both, Plus[One;Tensor[Atom "lex";Atom "się";Atom "qub"]];
+  Both, Plus[One;Tensor[Atom "padvp"]];
+]
+
+let verb_connected_adjuncts_simp = [
+  adjunct [Tensor[Atom "advp"; Atom "pron"]];
+  adjunct [Tensor[Atom "advp"; Atom "locat"]];
+  adjunct [Tensor[Atom "advp"; Atom "abl"]];
+  adjunct [Tensor[Atom "advp"; Atom "adl"]];
+  adjunct [Tensor[Atom "advp"; Atom "perl"]];
+  adjunct [Tensor[Atom "advp"; Atom "temp"]];
+  adjunct [Tensor[Atom "advp"; Atom "dur"]];
+  adjunct [Tensor[Atom "advp"; Atom "mod"]];
+  adjunct [Tensor[Atom "np";Top;Atom "dat"; Top; Top];Tensor[Atom "ncp"; Top; Atom "dat"; Top; Top; Top; Top]];
+  adjunct [Tensor[Atom "np";Top;Atom "inst"; Top; Top];Tensor[Atom "ncp"; Top; Atom "inst"; Top; Top; Top; Top]];
+  adjunct [Tensor[Atom "date"];Tensor[Atom "day-lex"];Tensor[Atom "day-month"];Tensor[Atom "day"]];
+  adjunct_dir Forward_ [Tensor[Atom "cp";Top; Top]];
+  adjunct [Tensor[Atom "or"]];
+  adjunct [Tensor[Atom "lex";Atom "się";Atom "qub"]];
+  adjunct_ce "3" [Tensor[Atom "padvp"]];
+]
+
+let proper_noun_adjuncts_simp = [
+  Both, Plus[One;Tensor[Atom "np";Top;Atom "gen"; Top; Top];Tensor[Atom "ncp"; Top; Atom "gen"; Top; Top; Top; Top]];
+  Forward, Plus[One;Tensor[Atom "np";Top;Atom "nom"; Top; Top];Tensor[Atom "np";Top;AVar "case"; Top; Top]];
+  Backward, Maybe(Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]);
+  Forward, Plus[One;Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+]
+
+let proper_noun_connected_adjuncts_simp = [
+  adjunct [Tensor[Atom "np";Top;Atom "gen"; Top; Top];Tensor[Atom "ncp"; Top; Atom "gen"; Top; Top; Top; Top]];
+  adjunct_dir Forward_ [Tensor[Atom "np";Top;Atom "nom"; Top; Top];Tensor[Atom "np";Top;AVar "case"; Top; Top]];
+  adjunct_multi Backward_ [Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+  adjunct_dir Forward_ [Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+]
+
+let common_noun_adjuncts_simp = [
+  Both, Plus[One;Tensor[Atom "np";Top;Atom "gen"; Top; Top];Tensor[Atom "ncp"; Top; Atom "gen"; Top; Top; Top; Top]];
+  Forward, Plus[One;Tensor[Atom "np";Top;Atom "nom"; Top; Top];Tensor[Atom "np";Top;AVar "case"; Top; Top]];
+  Backward, Maybe(Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]);
+  Forward, Plus[One;Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+]
+
+let common_noun_connected_adjuncts_simp = [
+  adjunct [Tensor[Atom "np";Top;Atom "gen"; Top; Top];Tensor[Atom "ncp"; Top; Atom "gen"; Top; Top; Top; Top]];
+  adjunct_dir Forward_ [Tensor[Atom "np";Top;Atom "nom"; Top; Top];Tensor[Atom "np";Top;AVar "case"; Top; Top]];
+  adjunct_multi Backward_ [Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+  adjunct_dir Forward_ [Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+]
+
+let measure_noun_adjuncts_simp = [
+  Backward, Maybe(Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]);
+  Forward, Plus[One;Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+]
+
+let measure_noun_connected_adjuncts_simp = [
+  adjunct_multi Backward_ [Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+  adjunct_dir Forward_ [Tensor[Atom "adjp"; AVar "number"; AVar "case"; AVar "gender"]];
+]
+
+let adj_adjuncts_simp = [
+  Both, Plus[One;Tensor[Atom "advp"; Top]];
+]
+
+let adj_connected_adjuncts_simp = [
+  adjunct [Tensor[Atom "advp"; Top]];
+]
+
+let adv_adjuncts_simp = [
+   Both, Plus[One;Tensor[Atom "advp"; Top]];
+ ]
+
+let adv_connected_adjuncts_simp = [
+   adjunct [Tensor[Atom "advp"; Top]];
+ ]
+
+let assing_prep_morfs = function
+    "po","postp" -> [
+        LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "dat"; Atom "m1"]);
+        LCG(Tensor[Atom "adjp"; Top; Atom "postp"; Top])]
+  | "z","postp" -> [LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "nom"; Atom "f"])]
+  | "na","postp" -> [LCG(Tensor[Atom "advp"; Top])]
+  | _,case -> [
+        LCG(Tensor[Atom "np"; Top; Atom case; Top; Top]);
+        LCG(Tensor[Atom "adjp"; Top; Atom case; Top])]
+
+let prep_morfs = [
+  LCG(Tensor[Atom "np"; Top; Atom "case"; Top; Top]);
+  LCG(Tensor[Atom "adjp"; Top; Atom "case"; Top]);
+  LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "dat"; Atom "m1"]);
+  LCG(Tensor[Atom "adjp"; Atom "sg"; Atom "nom"; Atom "f"]);
+  LCG(Tensor[Atom "advp"; Top]);
+  LCG(Tensor[Atom "year"]);
+  LCG(Tensor[Atom "hour-minute"]);
+  LCG(Tensor[Atom "day-month"]);
+  LCG(Tensor[Atom "hour"]);
+  LCG(Tensor[Atom "day"]);
+  LCG(Tensor[Atom "date"]);
+  ]
+
+let compar_morfs = [
+  LCG(Tensor[Atom "np"; Top; Atom "case"; Top; Top]);
+  LCG(Tensor[Atom "adjp"; Top; Atom "case"; Top]);
+  LCG(Tensor[Atom "prepnp"; Top; Top]);
+  LCG(Tensor[Atom "prepadjp"; Top; Top]);
+  ]
@@ -59,6 +59,7 @@ let case = function
   | CaseUndef -> "_"
   | AllAgr -> "allagr"
   | NomAgr -> "nomagr"
+  | VocAgr -> "vocagr"
   | GenAgr -> "genagr"
  
 let rec comp = function
@@ -140,7 +141,7 @@ let rec phrase = function
   | ComparP(prep,c) -> "comparp(" ^ prep ^ "," ^ case c ^ ")"
   | CP(ct,co) -> "cp(" ^ comp_type ct ^ "," ^ comp co ^ ")"
   | NCP(c,ct,co) -> "ncp(" ^ case c ^ "," ^ comp_type ct ^ "," ^ comp co ^ ")"
-  | PrepNCP(prep,c,ct,co) -> "prepncp(" ^ prep ^ "," ^ case c ^ "," ^ comp_type ct ^ "," ^ comp co ^ ")"
+  | PrepNCP(p,prep,c,ct,co) -> "prepncp(" ^ psem p ^ "," ^ prep ^ "," ^ case c ^ "," ^ comp_type ct ^ "," ^ comp co ^ ")"
   | InfP(a) -> "infp(" ^ aspect a (*^ req r*) ^ ")"
   | AdvP(m) -> "advp(" ^ m ^ ")"
   | ColonP -> "colonp"
@@ -250,7 +251,7 @@ let rec connected_schema schema =
       "{" ^  String.concat ";" (Xlist.map s.morfs simple_morf) ^ "}:" ^ sem_frame s))
 *)
  
-let meaning m =
+let sense m =
   m.name ^ "-" ^ m.variant
  
 let lex_entry = function
@@ -24,7 +24,7 @@ type opinion = Pewny | Potoczny | Watpliwy | Archaiczny | Zly | Wulgarny | Nieok
 type negation = Negation | Aff | NegationUndef (*| NegationNA*)
 type pred = PredTrue | PredFalse | PredUndef (*| PredNA*)
 type aspect = Aspect of string | AspectUndef (*| AspectNA*)
-type case = Case of string | Str | Part | CaseAgr | CaseUndef (*| AllUAgr | CaseUAgr*) | GenAgr | NomAgr | AllAgr
+type case = Case of string | Str | Part | CaseAgr | CaseUndef (*| AllUAgr | CaseUAgr*) | GenAgr | NomAgr | VocAgr | AllAgr
 type comp = Comp of string | Zeby | Gdy | CompUndef
 type comp_type = Int | Rel | CompTypeUndef (*| CompTypeAgr*)
 type number = Number of string | NumberUndef | NumberAgr
@@ -72,7 +72,7 @@ type phrase =
   | ComparP of string * case
   | CP of comp_type * comp
   | NCP of case * comp_type * comp
-  | PrepNCP of string * case * comp_type * comp
+  | PrepNCP of psem * string * case * comp_type * comp
   | InfP of aspect
   | AdvP of string
   | ColonP
@@ -108,34 +108,34 @@ type necessary = Req | Opt | Pro | ProNG | Multi
  
 type direction = Both_ | Forward_ | Backward_
  
-type position = {psn_id: int; gf: gf; role: string; role_attr: string; sel_prefs: sel_prefs list;
+type position = {psn_id: int; gf: gf; role: string; role_attr: string; node: string; sel_prefs: sel_prefs list; cat_prefs: string list;
                  mode: string list; cr: string list; ce: string list; morfs: phrase list;
                  dir: direction; is_necessary: necessary}
  
 let empty_position =
-  {psn_id=(-1); gf=ARG; role=""; role_attr=""; mode=[]; sel_prefs=[]; cr=[]; ce=[]; dir=Both_; morfs=[]; is_necessary=Opt}
+  {psn_id=(-1); gf=ARG; role=""; role_attr=""; mode=[]; node="concept"; sel_prefs=[]; cat_prefs=["X"]; cr=[]; ce=[]; dir=Both_; morfs=[]; is_necessary=Opt}
  
-type meaning = {mng_id: int;
+type sense = {mng_id: int;
                 name: string;
                 variant: string;
                 plwnluid: int;
                 gloss: string}
  
-let empty_meaning = {mng_id = (-1);
+let empty_sense = {mng_id = (-1);
                      name = "";
                      variant = "";
                      plwnluid = (-1);
                      gloss = ""}
  
 (* type frame_atrs =
-    EmptyAtrs of meaning list
-  | DefaultAtrs of meaning list * refl * opinion * negation * pred * aspect
+    EmptyAtrs of sense list
+  | DefaultAtrs of sense list * refl * opinion * negation * pred * aspect
   | ComprepAtrs of string
-  | NounAtrs of meaning list * string * nsem (** string list*)
-  | AdjAtrs of meaning list * case * string (** string * string list*)
-  | PersAtrs of meaning list * string * negation * mood * tense * aux * aspect
-  | GerAtrs of meaning list * string * negation * aspect
-  | NonPersAtrs of meaning list * string * string * string * negation * aspect *)
+  | NounAtrs of sense list * string * nsem (** string list*)
+  | AdjAtrs of sense list * case * string (** string * string list*)
+  | PersAtrs of sense list * string * negation * mood * tense * aux * aspect
+  | GerAtrs of sense list * string * negation * aspect
+  | NonPersAtrs of sense list * string * string * string * negation * aspect *)
  
 (* type schema = {sch_id: int; opinion: opinion; reflexiveMark: refl; aspect: aspect;
                negativity: negation; predicativity: pred; positions: position list; text_rep: string} *)
@@ -175,6 +175,6 @@ let phrases_filename = resource_path ^ &quot;/Walenty/phrases.tab&quot;
 let entries_filename = resource_path ^ "/Walenty/entries.tab"
 let schemata_filename = resource_path ^ "/Walenty/schemata.tab"
 let connected_filename = resource_path ^ "/Walenty/connected.tab"
-let meanings_filename = resource_path ^ "/Walenty/meanings.tab"
+let senses_filename = resource_path ^ "/Walenty/meanings.tab"
  
 let user_valence_filename = data_path ^ "/valence.dic"
@@ -4,4 +4,12 @@ sobie	siebie	siebie:dat.loc
 sobą	siebie	siebie:inst
 to	to	pred
 yay	yay	interj
+świetnie	świetnie	interj
+doskonale	doskonale	interj
+idealnie	idealnie	interj
+zdecydowanie	zdecydowanie	interj
+ok	ok	interj
+super	super	interj
+dobrze	dobrze	interj
+dzięki	dzięki	interj
  
@@ -25,7 +25,7 @@ let empty_concept =
   {c_sense=Dot;c_name=Dot;(* c_variable: string; c_visible_var: bool;*) c_quant=Dot; c_local_quant=true; (*c_modalities: (string * type_term) list;
    c_left_input_pos: int; c_right_input_pos: int;*) c_relations=Dot; c_variable="",""; c_pos=(-1); c_cat=Dot; c_label=""; c_def_label=""}
  
-let empty_context = {cx_sense=Dot; cx_contents=Dot; cx_relations=Dot; cx_variable="",""; cx_pos=(-1); cx_cat=Dot}
+let empty_context = {cx_sense=Dot; cx_contents=Dot; cx_relations=Dot; cx_variable="",""; cx_pos=(-1); cx_cat=Dot; cx_label=""; cx_def_label=""}
  
 let rec make_args_list = function
     Tuple l -> List.flatten (Xlist.map l make_args_list)
@@ -34,7 +34,7 @@ let rec make_args_list = function
 let symbols = StringSet.of_list [
   "symbol"; "date"; "date-interval"; "hour-minute"; "hour"; "hour-minute-interval"; "hour-interval";
   "year"; "year-interval"; "day"; "day-interval"; "day-month"; "day-month-interval"; "month-interval"; "roman"; "roman-interval";
-  "match-result"; "url"; "email"; "obj-id"; "building-number";
+  "match-result"; "url"; "email"; "phone-number"; "obj-id"; "building-number";
   "month-lex"; "day-lex"]
  
 let rec get_person = function
@@ -60,27 +60,27 @@ let make_relation t c =
   | "adjunct" -> MakeTripleRelation(t.arole,t.arole_attr,c)
   | s -> failwith ("make_make_triple_relation: " ^ s)*)
  
-(* let add_proj proj c =
-  if proj = Dot then Concept c else
-  Concept{empty_concept with c_cat=proj; c_relations=Tuple[Relation("Has","",Concept{c with c_relations=Dot});c.c_relations]} *)
-let add_proj proj c =
-  if proj = Dot then Concept c else
-  Concept{empty_concept with c_cat=proj; c_relations=Relation("Has","",Concept c)}
-(* let add_proj proj c =
-  if proj = Dot then Concept c else
-  let proj_rels,c_rels = split_relations c.c_relations in
-  Concept{empty_concept with c_cat=proj; c_relations=Tuple[Relation("Has","",Concept{c with c_relations=c_rels});proj_rels]} *)
-let add_proj2 proj c =
-  if proj = Dot then c else
-  Concept{empty_concept with c_cat=proj; c_relations=Relation("Has","",c)}
-
-
-let create_normal_concept tokens lex_sems t cat proj =
+(* let add_coerced coerced c =
+  if coerced = Dot then Concept c else
+  Concept{empty_concept with c_cat=coerced; c_relations=Tuple[Relation("Has","",Concept{c with c_relations=Dot});c.c_relations]} *)
+let add_coerced coerced c =
+  if coerced = Dot then Concept c else
+  Concept{empty_concept with c_cat=coerced; c_relations=Relation("Has","",Concept c)} (* FIXME: trzeba dodać concept do tokenów *)
+(* let add_coerced coerced c =
+  if coerced = Dot then Concept c else
+  let coerced_rels,c_rels = split_relations c.c_relations in
+  Concept{empty_concept with c_cat=coerced; c_relations=Tuple[Relation("Has","",Concept{c with c_relations=c_rels});coerced_rels]} *)
+let add_coerced2 coerced c =
+  if coerced = Dot then c else
+  Concept{empty_concept with c_cat=coerced; c_relations=Relation("Has","",c)} (* FIXME: trzeba dodać concept do tokenów *)
+
+
+let create_normal_concept tokens lex_sems t cat coerced =
   (*if t.agf = ENIAMwalTypes.NOSEM then t.args else*)
-  let cat,proj = if !user_ontology_flag then cat,proj else Dot,Dot in
-  let proj = if proj = cat then Dot else proj in
+  let cat,coerced = if !user_ontology_flag then cat,coerced else Dot,Dot in
+  let coerced = if coerced = cat then Dot else coerced in
   let c = {empty_concept with
-    c_sense =  if !user_ontology_flag then Val t.lemma else (*if t.lemma = "<root>" then Dot else*) t.meaning;
+    c_sense =  (*if !user_ontology_flag then Val t.lemma else*) (*if t.lemma = "<root>" then Dot else*) t.sense;
     c_relations=t.args;
     c_quant=if t.label = "" then t.sem_args else Dot; (* FIXME: zakładam że t.label <> "" występuje tylko dla pro *)
     c_variable=string_of_int t.id,"";
@@ -93,7 +93,7 @@ let create_normal_concept tokens lex_sems t cat proj =
     let c = {c with c_local_quant=false} in
     let c,measure,cx_flag = Xlist.fold t.attrs (c,false,false) (fun (c,measure,cx_flag) -> function
         "NSYN",Val "common" -> c,measure,cx_flag
-      | "NSYN",Val "proper" -> {c with c_name=Val t.lemma; c_sense=Dot(*t.meaning*)(*c_sense=if Val t.pred=c.c_sense then Dot else c.c_sense*)},measure,cx_flag; (* FIXME: zaślepka na potrzeby gramatyk semantycznych *)  (* Rozpoznawanie propoer names nieznanego typu - ryzykowne ale proste *)
+      | "NSYN",Val "proper" -> {c with c_name=Val t.lemma; c_sense=Dot(*t.sense*)(*c_sense=if Val t.pred=c.c_sense then Dot else c.c_sense*)},measure,cx_flag; (* FIXME: zaślepka na potrzeby gramatyk semantycznych *)  (* Rozpoznawanie propoer names nieznanego typu - ryzykowne ale proste *)
       | "NSYN",Val "pronoun" -> c(*{c with c_quant=Tuple[c.c_quant;Val "indexical"]}*),measure,cx_flag
       | "NSEM",Val "count" -> c(*{c with c_quant=Tuple[c.c_quant;Val "count"]}*),measure,cx_flag
       | "NSEM",Val "mass" -> {c with c_quant=Tuple[c.c_quant;Val "mass"]},measure,cx_flag
@@ -120,13 +120,13 @@ let create_normal_concept tokens lex_sems t cat proj =
     if cx_flag then
       let id = ExtArray.add tokens ENIAMtokenizerTypes.empty_token_env in
       let _ = ExtArray.add lex_sems ENIAMlexSemanticsTypes.empty_lex_sem in
-      make_relation t (Context{empty_context with cx_contents=add_proj proj c; cx_variable=string_of_int id,""; cx_pos=c.c_pos})
+      make_relation t (Context{empty_context with cx_contents=add_coerced coerced c; cx_variable=string_of_int id,""; cx_pos=c.c_pos})
     else
-      make_relation t (add_proj proj c) else
+      make_relation t (add_coerced coerced c) else
   if t.pos = "fin" || t.pos = "bedzie" || t.pos = "praet" || t.pos = "winien" || t.pos = "impt" || t.pos = "imps" || t.pos = "pred" || t.lemma = "pro-komunikować" then
     let c = {c with c_local_quant=false} in
     let c = Xlist.fold t.attrs c (fun c -> function
-(*         "MEANING",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
+(*         "SENSE",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
       | "NUM",t -> c
       | "GEND",_ -> c
       | "PERS",_ -> c
@@ -142,7 +142,7 @@ let create_normal_concept tokens lex_sems t cat proj =
     let c = if t.lemma = "pro-komunikować" then {c with c_relations=Relation("Theme","",c.c_relations)} else c in (* FIXME: to by trzeba przesunąć na wcześniej *)
     let id = ExtArray.add tokens ENIAMtokenizerTypes.empty_token_env in
     let _ = ExtArray.add lex_sems ENIAMlexSemanticsTypes.empty_lex_sem in
-    let cx = {empty_context with cx_contents=add_proj proj c; cx_variable=string_of_int id,""; cx_pos=c.c_pos; cx_cat=Val "Situation"} in
+    let cx = {empty_context with cx_contents=add_coerced coerced c; cx_variable=string_of_int id,""; cx_pos=c.c_pos; cx_cat=Val "Situation"} in
     (* if t.role <> "" || t.role_attr <> "" then failwith "create_normal_concept: verb" else *)
     make_relation t (Context cx) else
   if t.pos = "inf" then
@@ -154,13 +154,13 @@ let create_normal_concept tokens lex_sems t cat proj =
       | "NEGATION",Val "neg" -> {c with c_quant=Tuple[c.c_quant;Val "nie"]}
       | e,t -> failwith ("create_normal_concept verb: " ^ e)) in
     let id = ExtArray.add tokens ENIAMtokenizerTypes.empty_token_env in
-    let _ = ExtArray.add lex_sems  in
-    let cx = {empty_context with cx_contents=add_proj proj c; cx_variable=string_of_int id,""; cx_pos=c.c_pos; cx_cat=Val "Situation"} in
+    let _ = ExtArray.add lex_sems ENIAMlexSemanticsTypes.empty_lex_sem in
+    let cx = {empty_context with cx_contents=add_coerced coerced c; cx_variable=string_of_int id,""; cx_pos=c.c_pos; cx_cat=Val "Situation"} in
     make_relation t (Context cx) else
   if t.pos = "adj" || t.pos = "adjc" || t.pos = "adjp" || t.pos = "adja" || t.pos = "pact" || t.pos = "ppas" || t.pos = "apron" || t.pos = "ordnum" || t.pos = "roman-adj" then
     let c = if t.pos = "pact" || t.pos = "ppas" then {c with c_local_quant=false} else c in
     let c = Xlist.fold t.attrs c (fun c -> function
-(*         "MEANING",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
+(*         "SENSE",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
       | "SYN",Val "common" -> c
       | "SYN",Val "pronoun" -> c(*{c with c_quant=Tuple[c.c_quant;Val "indexical"]}*)
       | "SYN",Val "proper" -> if t.pos = "roman-adj" then c else failwith "create_normal_concept adj: SYN=proper"
@@ -172,6 +172,7 @@ let create_normal_concept tokens lex_sems t cat proj =
       | "GRAD",Val "com" -> {c with c_relations=Tuple[c.c_relations;SingleRelation (Val "com")]}
       | "GRAD",Val "sup" -> {c with c_relations=Tuple[c.c_relations;SingleRelation (Val "sup")]}
       | "ASPECT",_ -> c
+      | "CTYPE",_ -> c (* FIXME1: trzeba zaznaczyć pytajność w grafie, CTYPE pojawia się w dwu węzłach *)
 (*       | "TYPE",Val "int" -> {c with c_quant=Tuple[c.c_quant;Val "interrogative"]} *)
       | "TYPE",_ -> c (* FIXME *)
       | "PERS",_ -> c
@@ -183,7 +184,7 @@ let create_normal_concept tokens lex_sems t cat proj =
   if t.pos = "adv" || t.pos = "pcon" || t.pos = "pant" then
     let c = if t.pos = "pcon" || t.pos = "pant" then {c with c_local_quant=false} else c in
     let c = Xlist.fold t.attrs c (fun c -> function
-(*         "MEANING",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
+(*         "SENSE",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
       | "GRAD",Val "pos" -> c
       | "GRAD",Val "com" -> {c with c_relations=Tuple[c.c_relations;SingleRelation (Val "com")]}
       | "GRAD",Val "sup" -> {c with c_relations=Tuple[c.c_relations;SingleRelation (Val "sup")]}
@@ -194,7 +195,7 @@ let create_normal_concept tokens lex_sems t cat proj =
       | "NEGATION",Val "aff" -> c
       | "NEGATION",Val "neg" -> {c with c_quant=Tuple[c.c_quant;Val "nie"]}
       | e,t -> failwith ("create_normal_concept adv: " ^ e)) in
-    make_relation t (add_proj proj c) else
+    make_relation t (add_coerced coerced c) else
   if t.pos = "prep" then
     (* if t.arole = "NOSEM" then make_relation t (t.args) else *)
     let c,is_sem = Xlist.fold t.attrs (c,false) (fun (c,is_sem) -> function
@@ -203,9 +204,9 @@ let create_normal_concept tokens lex_sems t cat proj =
       | "PSEM",Val "nosem" -> c,false
       | e,t -> failwith ("create_normal_concept prep: " ^ e)) in
     (* make_make_triple_relation t (Concept c) else *)
-    if is_sem then make_relation t (add_proj2 proj (CreateContext({empty_context with cx_sense=c.c_sense; cx_variable=c.c_variable; cx_pos=c.c_pos; cx_cat=c.c_cat},c.c_relations)))
+    if is_sem then make_relation t (add_coerced2 coerced (CreateContext({empty_context with cx_sense=c.c_sense; cx_variable=c.c_variable; cx_pos=c.c_pos; cx_cat=c.c_cat},c.c_relations)))
     else make_relation t (RemoveRelation("CORE","",c.c_relations)) else
-  if proj <> Dot then failwith ("create_normal_concept proj: " ^ t.lemma) else
+  if coerced <> Dot then failwith ("create_normal_concept coerced: " ^ t.lemma) else
   if t.pos = "pro" || t.pos = "ppron12" || t.pos = "ppron3" || t.pos = "siebie" then (* FIXME: indexicalność *)
     let c = {c with c_local_quant=false} in
     let c = Xlist.fold t.attrs c (fun c -> function
@@ -225,7 +226,7 @@ let create_normal_concept tokens lex_sems t cat proj =
     make_relation t (Concept c) else
   if t.pos = "num" || t.pos = "intnum" || t.pos = "realnum" || t.pos = "intnum-interval" || t.pos = "realnum-interval" then
     let c = Xlist.fold t.attrs c (fun c -> function
-(*         "MEANING",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
+(*         "SENSE",t -> {c with c_sense=Tuple[c.c_sense;t]} *)
       | "ACM",_ -> c
       | "NUM",_ -> c
       | "CASE",_ -> c
@@ -249,12 +250,15 @@ let create_normal_concept tokens lex_sems t cat proj =
   if t.pos = "comp" then
     make_relation t (SetContextName(c.c_sense,RemoveRelation("CORE","",c.c_relations))) else
   if t.pos = "conj" then
-    let c = {empty_context with cx_sense=t.meaning; cx_contents=t.args; cx_variable=c.c_variable; cx_pos=c.c_pos} in
+    let c = {empty_context with cx_sense=t.sense; cx_contents=t.args; cx_variable=c.c_variable; cx_pos=c.c_pos; cx_cat=c.c_cat; cx_def_label=c.c_def_label; cx_label=c.c_label} in
     let c = Xlist.fold t.attrs c (fun c -> function
       | "NUM",_ -> c
       | "CASE",_ -> c
       | "GEND",_ -> c
       | "PERS",_ -> c
+      | "ASPECT",_ -> c
+      | "controller",_ -> c
+      | "controllee",_ -> c
       | e,t -> failwith ("create_normal_concept conj: " ^ e)) in
     ManageCoordination({t with attrs=[]; args=Dot},Context c) else
   (* if t.pos = "interj" then
@@ -264,16 +268,25 @@ let create_normal_concept tokens lex_sems t cat proj =
   if t.pos = "sinterj" || t.pos = "interj" then
     let c = Xlist.fold t.attrs c (fun c -> function
       | e,t -> failwith ("create_normal_concept sinterj: " ^ e)) in
-    make_relation t (Concept c) else
+    let id = ExtArray.add tokens ENIAMtokenizerTypes.empty_token_env in
+    let _ = ExtArray.add lex_sems ENIAMlexSemanticsTypes.empty_lex_sem in
+    let cx = {empty_context with cx_contents=add_coerced coerced c; cx_variable=string_of_int id,""; cx_pos=c.c_pos; cx_cat=Val "Situation"} in
+    make_relation t (Context cx) else
   if t.lemma = "<root>" then t.args else
   if t.lemma = "<merge>" then RemoveRelation("null","",t.args) else
-  if t.pos = "interp" && t.lemma = "?" && t.args = Dot then SingleRelation(Val "int") else
+  (* if t.pos = "interp" && t.lemma = "?" && t.args = Dot then SingleRelation(Val "int") else *)
+  if t.pos = "interp" && t.lemma = "?" then
+    make_relation t (AddSingleRelation(Val "int",RemoveRelation("CORE","",t.args))) else (* FIXME1: to powinno tworzyć kontekst i zaznaczać ze jest interrogative *)
   if t.pos = "interp" && t.lemma = ":" then
     make_relation t (RemoveRelation("CORE","",t.args)) else
   if t.pos = "interp" && t.lemma = "</sentence>" then
     let l = (*List.rev*) (make_args_list t.args) in
     Xlist.fold (List.tl l) (RemoveRelation("null","",List.hd l)) (fun t s -> AddRelation(t,"Next","Clause",RemoveRelation("null","",s))) else
   if t.pos = "interp" && t.lemma = "<sentence>" then t.args else
+  if t.pos = "interp" && t.lemma = "</query>" then
+    let l = (*List.rev*) (make_args_list t.args) in
+    Xlist.fold (List.tl l) (List.hd l) (fun t s -> AddRelation(t,"Next","Sentence",s)) else
+  if t.pos = "interp" && t.lemma = "<query>" then t.args else
 (*  if t.pos = "interp" && t.lemma = "”s" then
     let l = List.rev (make_args_list t.args) in
     let x = Xlist.fold (List.tl l) (List.hd l) (fun t s -> AddRelation(RemoveRelation t,"Next","Sentence",RemoveRelation s)) in
@@ -310,54 +323,55 @@ let rec translate_node tokens lex_sems t =
     orth=t.ENIAM_LCGtypes.orth; lemma=t.ENIAM_LCGtypes.lemma; pos=t.ENIAM_LCGtypes.pos; weight=t.ENIAM_LCGtypes.weight;
     id=t.ENIAM_LCGtypes.id; symbol=create_concepts tokens lex_sems t.ENIAM_LCGtypes.symbol; arg_symbol=create_concepts tokens lex_sems t.ENIAM_LCGtypes.arg_symbol;
     arg_dir=t.ENIAM_LCGtypes.arg_dir;
-    attrs=[]; label=""; def_label="";
+    attrs=[]; label=""; def_label=""; snode="";
     args=create_concepts tokens lex_sems t.ENIAM_LCGtypes.args;
-    gf=""; role=""; role_attr=""; selprefs=Dot; meaning=Dot; arole=""; arole_attr=""; arev=false; sem_args=Dot} in
-  let t,attrs,cat,proj = Xlist.fold attrs (t,[],Dot,Dot) (fun (t,attrs,cat,proj) -> function
-      "gf",Val s -> {t with gf=s},attrs,cat,proj
-    | "role",Val s -> {t with role=s},attrs,cat,proj
-    | "role-attr",Val s -> {t with role_attr=s},attrs,cat,proj
-    | "selprefs",s -> {t with selprefs=s},attrs,cat,proj
-    | "meaning",s -> {t with meaning=s},attrs,cat,proj
-    | "hipero",_ -> t,attrs,cat,proj
-    | "arole",Val s -> {t with arole=s},attrs,cat,proj
-    | "arole-attr",Val s -> {t with arole_attr=s},attrs,cat,proj
-    | "arev",Val "-" -> {t with arev=false},attrs,cat,proj
-    | "arev",Val "+" -> {t with arev=true},attrs,cat,proj
-    | "agf",Val s -> t,attrs,cat,proj
-    | "sem-args",s -> {t with sem_args=s},attrs,cat,proj
-    | "rev-hipero",_ -> t,attrs,cat,proj
-    | "fopinion",_ -> t,attrs,cat,proj
-    | "sopinion",_ -> t,attrs,cat,proj
-    | "ACM",s -> t,("ACM",s) :: attrs,cat,proj
-    | "ASPECT",s -> t,("ASPECT",s) :: attrs,cat,proj
-    | "NEGATION",s -> t,("NEGATION",s) :: attrs,cat,proj
-    | "MOOD",s -> t,("MOOD",s) :: attrs,cat,proj
-    | "TENSE",s -> t,("TENSE",s) :: attrs,cat,proj
-    | "controller",s -> t,("controller",s) :: attrs,cat,proj
-    | "controllee",s -> t,("controllee",s) :: attrs,cat,proj
-    | "coref",s -> t,attrs,cat,proj
-    | "label",Val s -> {t with label=s},attrs,cat,proj
-    | "def-label",Val s -> {t with def_label=s},attrs,cat,proj
-    | "CAT",s -> t,attrs,s,proj
-    | "PROJ",s -> t,attrs,cat,s
-    | "NUM",s -> t,("NUM",s) :: attrs,cat,proj
-    | "CASE",s -> t,("CASE",s) :: attrs,cat,proj
-    | "GEND",s -> t,("GEND",s) :: attrs,cat,proj
-    | "PERS",s -> t,("PERS",s) :: attrs,cat,proj
-    | "NSYN",s -> t,("NSYN",s) :: attrs,cat,proj
-    | "NSEM",s -> t,("NSEM",s) :: attrs,cat,proj
-    | "MODE",s -> t,("MODE",s) :: attrs,cat,proj
-    | "GRAD",s -> t,("GRAD",s) :: attrs,cat,proj
-    | "PSEM",s -> t,("PSEM",s) :: attrs,cat,proj
-    (* | k,v -> printf "translate_node: %s %s\n%!" k (ENIAMsemStringOf.linear_term 0 v); t, (k,v) :: attrs,cat,proj) in *)
+    gf=""; role=""; role_attr=""; selprefs=Dot; sense=Dot; arole=""; arole_attr=""; arev=false; sem_args=Dot} in
+  let t,attrs,cat,coerced = Xlist.fold attrs (t,[],Dot,Dot) (fun (t,attrs,cat,coerced) -> function
+      "gf",Val s -> {t with gf=s},attrs,cat,coerced
+    | "role",Val s -> {t with role=s},attrs,cat,coerced
+    | "role-attr",Val s -> {t with role_attr=s},attrs,cat,coerced
+    | "selprefs",s -> {t with selprefs=s},attrs,cat,coerced
+    | "sense",s -> {t with sense=s},attrs,cat,coerced
+    | "hipero",_ -> t,attrs,cat,coerced
+    | "arole",Val s -> {t with arole=s},attrs,cat,coerced
+    | "arole-attr",Val s -> {t with arole_attr=s},attrs,cat,coerced
+    | "arev",Val "-" -> {t with arev=false},attrs,cat,coerced
+    | "arev",Val "+" -> {t with arev=true},attrs,cat,coerced
+    | "agf",Val s -> t,attrs,cat,coerced
+    | "sem-args",s -> {t with sem_args=s},attrs,cat,coerced
+    | "rev-hipero",_ -> t,attrs,cat,coerced
+    | "fopinion",_ -> t,attrs,cat,coerced
+    | "sopinion",_ -> t,attrs,cat,coerced
+    | "ACM",s -> t,("ACM",s) :: attrs,cat,coerced
+    | "ASPECT",s -> t,("ASPECT",s) :: attrs,cat,coerced
+    | "NEGATION",s -> t,("NEGATION",s) :: attrs,cat,coerced
+    | "MOOD",s -> t,("MOOD",s) :: attrs,cat,coerced
+    | "TENSE",s -> t,("TENSE",s) :: attrs,cat,coerced
+    | "CTYPE",s -> t,("CTYPE",s) :: attrs,cat,coerced
+    | "controller",s -> t,("controller",s) :: attrs,cat,coerced
+    | "controllee",s -> t,("controllee",s) :: attrs,cat,coerced
+    | "coref",s -> t,attrs,cat,coerced
+    | "label",Val s -> {t with label=s},attrs,cat,coerced
+    | "def-label",Val s -> {t with def_label=s},attrs,cat,coerced
+    | "CAT",s -> t,attrs,s,coerced
+    | "COERCED",s -> t,attrs,cat,s
+    | "NUM",s -> t,("NUM",s) :: attrs,cat,coerced
+    | "CASE",s -> t,("CASE",s) :: attrs,cat,coerced
+    | "GEND",s -> t,("GEND",s) :: attrs,cat,coerced
+    | "PERS",s -> t,("PERS",s) :: attrs,cat,coerced
+    | "NSYN",s -> t,("NSYN",s) :: attrs,cat,coerced
+    | "NSEM",s -> t,("NSEM",s) :: attrs,cat,coerced
+    | "MODE",s -> t,("MODE",s) :: attrs,cat,coerced
+    | "GRAD",s -> t,("GRAD",s) :: attrs,cat,coerced
+    | "PSEM",s -> t,("PSEM",s) :: attrs,cat,coerced
+    (* | k,v -> printf "translate_node: %s %s\n%!" k (ENIAMsemStringOf.linear_term 0 v); t, (k,v) :: attrs,cat,coerced) in *)
     | k,v -> failwith (sprintf "translate_node: %s %s\n%!" k (ENIAMsemStringOf.linear_term 0 v))) in
-  {t with attrs=attrs},cat,proj
+  {t with attrs=attrs},cat,coerced
  
 and create_concepts tokens lex_sems = function
     ENIAM_LCGtypes.Node t ->
-      let t,cat,proj = translate_node tokens lex_sems t in
-      create_normal_concept tokens lex_sems t cat proj
+      let t,cat,coerced = translate_node tokens lex_sems t in
+      create_normal_concept tokens lex_sems t cat coerced
   | ENIAM_LCGtypes.Tuple l -> Tuple(Xlist.map l (create_concepts tokens lex_sems))
   | ENIAM_LCGtypes.Variant(e,l) -> Variant(e,Xlist.map l (fun (i,t) -> i, create_concepts tokens lex_sems t))
   | ENIAM_LCGtypes.Dot -> Dot
@@ -382,6 +396,7 @@ let rec make_tree_rec references = function
   | SingleRelation r  -> SingleRelation r
   (* | TripleRelation(r,a,s,t) -> TripleRelation(r,a,make_tree_rec references s,make_tree_rec references t) *)
   | AddRelation(t,r,a,s) -> AddRelation(make_tree_rec references t,r,a,make_tree_rec references s)
+  | AddSingleRelation(r,s) -> AddSingleRelation(r,make_tree_rec references s)
   | RemoveRelation(r,a,t) -> RemoveRelation(r,a,make_tree_rec references t)
   | SetContextName(s,t) -> SetContextName(s,make_tree_rec references t)
   | CreateContext(s,t) -> CreateContext(s,make_tree_rec references t)
@@ -408,13 +423,16 @@ let rec validate_translation r = function
   | SingleRelation _  -> ()
   (* | TripleRelation(_,_,s,t) -> validate_translation r s; validate_translation r t *)
   | AddRelation(t,_,_,s) -> validate_translation r t; validate_translation r s
+  | AddSingleRelation(_,s) -> validate_translation r s
   | RemoveRelation(_,_,t) -> validate_translation r t
   | SetContextName(s,t) -> validate_translation r t
   | CreateContext(s,t) -> validate_translation r t
   (* | MakeTripleRelation(_,_,t) -> validate_translation r t *)
   | ManageCoordination(_,t) -> validate_translation r t
   | Tuple l -> Xlist.iter l (validate_translation r)
-  | Variant(e,l) -> Xlist.iter l (fun (i,t) -> validate_translation r t)
+  | Variant(e,l) ->
+      if e = "" then r := "validate_translation: empty variant label" :: !r;
+      Xlist.iter l (fun (i,t) -> validate_translation r t)
   | Dot -> ()
   | t -> failwith ("validate_translation: " ^ ENIAMsemStringOf.linear_term 0 t)
  
@@ -500,6 +518,14 @@ let rec reduce_tree = function
   (* | TripleRelation(r,a,s,t) -> TripleRelation(r,a,reduce_tree s,reduce_tree t) *)
 (*  | AddRelation(Concept c,r,a,s) -> reduce_tree (Concept{c with c_relations=Tuple[Relation(Val r,Val a,s);c.c_relations]})
   | AddRelation(Context c,r,a,s) -> reduce_tree (Context{c with cx_relations=Tuple[Relation(Val r,Val a,s);c.cx_relations]})*)
+  | AddSingleRelation(r,t) ->
+      (match reduce_tree t with
+        Concept t -> Concept{t with c_relations=Tuple[t.c_relations;SingleRelation r]}
+      | Context({cx_sense=Val "czy"} as t) -> Context t
+      | Context({cx_sense=Val "jaki"} as t) -> Context t
+      | Context({cx_sense=Dot} as t) -> Context{t with cx_sense=Val "czy"}
+      | Variant(e,l) -> Variant(e,Xlist.map l (fun (i,t) -> i, reduce_tree (AddSingleRelation(r,t))))
+      | t -> AddSingleRelation(r,t))
   | AddRelation(t,r,a,s) -> simplify_tree_add_relation r a (reduce_tree s) (reduce_tree t)
 (*      let t = reduce_tree t in
       let s = reduce_tree s in
@@ -511,7 +537,7 @@ let rec reduce_tree = function
       (match reduce_tree t with
         Relation(r,a,t) ->
             if (r = r0 && a = a0) || r0 = "" then t else
-            Context{empty_context with cx_contents=
+            Context{empty_context with cx_cat=Val "Situation"; cx_contents=
               Concept{empty_concept with c_relations=Relation(r,a,t)}; (*cx_variable=string_of_int id,""; cx_pos=c.c_pos*)}
       (* | TripleRelation(r,a,s,t) ->
             Context{empty_context with cx_contents=
@@ -544,7 +570,8 @@ let rec reduce_tree = function
       (match reduce_tree c with
         Context c ->
            let t,args = extract_aroles {t with arole=""} c.cx_contents in
-           make_relation t (Context {c with cx_contents=args})
+           (*make_relation t (Context {c with cx_contents=args})*) (* FIXME: to trzeba poprawić tak by działało w obu wersjach parserów *)
+           Relation(t.role,"",Context {c with cx_contents=args})
       | Variant(e,l) -> reduce_tree (Variant(e,Xlist.map l (fun (i,c) -> i,ManageCoordination(t,c))))
       | c -> ManageCoordination(t,c))
   | Tuple l -> Tuple(List.rev (Xlist.rev_map l reduce_tree))
@@ -561,7 +588,9 @@ let rec validate_reduction r = function
   | SingleRelation _  -> ()
   (* | TripleRelation(_,_,s,t) -> validate_reduction r s; validate_reduction r t *)
   | Tuple l -> Xlist.iter l (validate_reduction r)
-  | Variant(e,l) -> Xlist.iter l (fun (i,t) -> validate_reduction r t)
+  | Variant(e,l) ->
+      if e = "" then r := "validate_reduction: empty variant label" :: !r;
+      Xlist.iter l (fun (i,t) -> validate_reduction r t)
   | Dot -> ()
   | t -> r := ("validate_reduction: " ^ ENIAMsemStringOf.linear_term 0 t) :: !r
  
@@ -605,6 +634,38 @@ let rec remove_variant_labels map = function
   | Val s -> Val s
   | t -> failwith ("remove_variant_labels: " ^ ENIAMsemStringOf.linear_term 0 t)
  
+let rec set_variant_labels map = function
+    Concept c -> Concept{c with
+      c_sense=set_variant_labels map c.c_sense;
+      c_name=set_variant_labels map c.c_name;
+      c_quant=set_variant_labels map c.c_quant;
+      c_cat=set_variant_labels map c.c_cat;
+      c_relations=set_variant_labels map c.c_relations}
+  | Context c -> Context{c with
+      cx_sense=set_variant_labels map c.cx_sense;
+      cx_contents=set_variant_labels map c.cx_contents;
+      cx_cat=set_variant_labels map c.cx_cat;
+      cx_relations=set_variant_labels map c.cx_relations}
+  | Relation(r,a,t) -> Relation(r,a,set_variant_labels map t)
+  | RevRelation(r,a,t) -> RevRelation(r,a,set_variant_labels map t)
+  | SingleRelation r  -> SingleRelation r
+  | Tuple l -> Tuple(List.rev (Xlist.rev_map l (set_variant_labels map)))
+  | Variant(e,l) ->
+      let e = try StringMap.find map e with Not_found -> ENIAM_LCGreductions.get_variant_label () in
+      let l = Xlist.rev_map l (fun (i,t) -> i, set_variant_labels map t) in
+      Variant(e,List.rev l)
+  | Dot -> Dot
+  | Val s -> Val s
+  | t -> failwith ("set_variant_labels: " ^ ENIAMsemStringOf.linear_term 0 t)
+
+let manage_variant_labels t =
+  ENIAM_LCGreductions.reset_variant_label ();
+  let qmap = count_variant_labels StringQMap.empty t in
+  let map = StringQMap.fold qmap StringMap.empty (fun map k _ ->
+    if k = "" then map else
+    StringMap.add map k (ENIAM_LCGreductions.get_variant_label ())) in
+  set_variant_labels map t
+
 let rec simplify_tree = function
     Concept c -> Concept{c with
       c_sense=simplify_tree c.c_sense;
@@ -625,6 +686,7 @@ let rec simplify_tree = function
       let l = Xlist.fold l [] (fun l t ->
         match simplify_tree t with
           Dot -> l
+        | Tuple l2 -> l2 @ l
         | t -> t :: l) in
       (match l with
         [] -> Dot
@@ -655,7 +717,8 @@ let rec simplify_tree = function
                c_cat = simplify_tree (Variant(e,lt3))}
          | Context c ->
              let lt1,lt2,lt3 = Xlist.fold l ([],[],[]) (fun (lt1,lt2,lt3) -> function
-                 i,Context c2 -> if c.cx_sense = c2.cx_sense then (i,c2.cx_contents) :: lt1, (i,c2.cx_relations) :: lt2, (i,c2.cx_cat) :: lt3 else raise Not_found
+                 i,Context c2 -> if c.cx_sense = c2.cx_sense && c.cx_label = c2.cx_label &&
+                      c.cx_def_label = c2.cx_def_label then (i,c2.cx_contents) :: lt1, (i,c2.cx_relations) :: lt2, (i,c2.cx_cat) :: lt3 else raise Not_found
                | _ -> raise Not_found) in
              let e = if e = "" then ENIAM_LCGreductions.get_variant_label () else e in
              Context{c with
@@ -32,7 +32,7 @@ let string_of_node t =
   let l = [
     "ORTH",Val t.orth;"LEMMA",Val t.lemma;"POS",Val t.pos;"ID",Val (string_of_int t.id);"LABEL",Val t.label;"DEF-LABEL",Val t.def_label;"WEIGHT",Val (string_of_float t.weight);
     "SYMBOL",t.symbol;"ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir;
-    "GF",Val t.gf;"ROLE",Val t.role;"ROLE_ATTR",Val t.role_attr;"SELPREFS",t.selprefs;"MEANING",t.meaning;
+    "GF",Val t.gf;"ROLE",Val t.role;"ROLE_ATTR",Val t.role_attr;"SELPREFS",t.selprefs;"SENSE",t.sense;
     "AROLE",Val t.arole;"AROLE_ATTR",Val t.role_attr;"AREV",Val (string_of_bool t.arev);"SEM_ARGS",t.sem_args] @ t.attrs in
   "{ " ^ String.concat " | " (Xlist.map l (fun (e,t) -> "{ " ^ e ^ " | " ^ escape_string (ENIAMsemStringOf.linear_term 0 t) ^ " }")) ^ " }"
  
@@ -225,7 +225,9 @@ let rec print_graph2_rec file edge_rev edge_label edge_style edge_head upper = f
   | Context t ->
           let id = !id_counter in
           incr id_counter;
-          fprintf file "  subgraph cluster%d {\nlabel=\"%s%s\"\n" id
+          fprintf file "  subgraph cluster%d {\nlabel=\"%s%s%s%s\"\n" id
+            (if t.cx_label="" then "" else "?" ^ t.cx_label ^ " ")
+            (if t.cx_def_label="" then "" else "*" ^ t.cx_def_label ^ " ")
             (if t.cx_cat=Dot then "" else escape_string (ENIAMsemStringOf.linear_term 0 t.cx_cat ^ " "))
             (if t.cx_sense = Dot then "" else escape_string (ENIAMsemStringOf.linear_term 0 t.cx_sense));
           let iid = print_graph2_rec file false "" "" "" 0 t.cx_contents in
@@ -268,6 +270,13 @@ let rec print_graph2_rec file edge_rev edge_label edge_style edge_head upper = f
           let _ = print_graph2_rec file false "" "" "" id t in
           let _ = print_graph2_rec file false "" "" "" id s in
           id
+  | AddSingleRelation(role,t) ->
+          let id = !id_counter in
+          incr id_counter;
+          fprintf file "  %d [shape=circle,label=\"AddSingleRelation\\n%s\"]\n" id (ENIAMsemStringOf.linear_term 0 role);
+          print_edge2 file edge_rev edge_label edge_style edge_head "" upper id;
+          let _ = print_graph2_rec file false "" "" "" id t in
+          id
   | RemoveRelation(role,role_attr,t) ->
           let id = !id_counter in
           incr id_counter;
@@ -50,7 +50,7 @@ let rec linear_term c = function
                                         "WEIGHT",Val (string_of_float t.weight);"SYMBOL",t.symbol;
                                         "ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir;
                                         "GF",Val t.gf; "ROLE", Val t.role; "ROLE-ATTR", Val t.role_attr;
-                                        "SELPREFS",t.selprefs; "MEANING",t.meaning;
+                                        "SELPREFS",t.selprefs; "SENSE",t.sense;
                                         "AROLE", Val t.role; "AROLE-ATTR", Val t.role_attr; "AREV", Val (if t.arev then "+" else "-");
                                         "SEM-ARGS",t.sem_args; "ARGS",t.args] @ t.attrs) (fun (e,t) ->
          "\\text{" ^ (Xlatex.escape_string e) ^ "} & " ^ (linear_term 0 t)))) ^ "\\end{array}\\right]}"
@@ -66,7 +66,7 @@ let rec linear_term c = function
   | Context c ->
     "{\\left[\\begin{array}{ll}" ^
     (String.concat "\\\\ " (Xlist.map ([
-         "SENSE",c.cx_sense;"CAT",c.cx_cat;
+         "SENSE",c.cx_sense;"CAT",c.cx_cat;"LABEL",Val c.cx_label;"DEF-LABEL",Val c.cx_def_label;
          "VARIABLE",Val (fst c.cx_variable ^ "_" ^ snd c.cx_variable);"POS",Val (string_of_int c.cx_pos);
          "RELATIONS",c.cx_relations;"CONTENTS",c.cx_contents]) (fun (e,t) ->
         "\\text{" ^ (Xlatex.escape_string e) ^ "} & " ^ (linear_term 0 t)))) ^ "\\end{array}\\right]}"
@@ -75,6 +75,7 @@ let rec linear_term c = function
   | SingleRelation r -> "{\\bf singlerelation}(" ^ linear_term 0 r ^ ")"
   (* | TripleRelation(r,a,c,t) -> "{\\bf triplerelation}(" ^ (*linear_term 0*) r ^ "," ^ (*linear_term 0*) a ^ "," ^ linear_term 0 c ^ "," ^ linear_term 0 t ^ ")" *)
   | AddRelation(t,r,a,s) -> "{\\bf addrelation}(" ^ linear_term 0 t ^ "," ^ r ^ "," ^ a ^ "," ^ linear_term 0 s ^ ")"
+  | AddSingleRelation(r,s) -> "{\\bf addrelation}(" ^ linear_term 0 r ^ "," ^ linear_term 0 s ^ ")"
   | RemoveRelation(r,a,t) -> "{\\bf removerelation}(" ^ r ^ "," ^ a ^ "," ^ linear_term 0 t ^ ")"
   | SetContextName(s,t) -> "{\\bf setcontextname}(" ^ linear_term 0 s ^ "," ^ linear_term 0 t ^ ")"
   | CreateContext(s,t) -> "{\\bf createcontext}(" ^ linear_term 0 (Context s) ^ "," ^ linear_term 0 t ^ ")"
@@ -45,7 +45,7 @@ let parse_multi p = function
   | tokens -> tokens,p
  
 let parse_morf p = function
-    [T "1"] -> {p with is_necessary=Opt}
+    [T "1"] -> if p.is_necessary=Multi then p else {p with is_necessary=Opt}
   | tokens ->
       let l = Xlist.map (try Lexer.split_symbol (T "*") [] tokens with _ -> failwith "parse_morf: split_symbol *") (function
           [T s] -> Atom s
@@ -75,6 +75,7 @@ let parse_role p = function
   | "Has" -> {p with role="Has"; sel_prefs=[SynsetName "ALL"]}
   | "PHas" -> {p with role="PHas"; sel_prefs=[SynsetName "ALL"]}
   | "PApoz" -> {p with role="PApoz"; sel_prefs=[SynsetName "ALL"]}
+  | "Merge" -> {p with role="Merge"; sel_prefs=[SynsetName "ALL"]}
   | s -> failwith ("parse_role: " ^ s)
  
 let parse_entry = function
@@ -43,7 +43,7 @@ let rec linear_term c = function
   | Context c ->
     "[" ^
     (String.concat "; " (Xlist.map ([
-         "SENSE",c.cx_sense;"CAT",c.cx_cat;
+         "SENSE",c.cx_sense;"CAT",c.cx_cat;"LABEL",Val c.cx_label;"DEF-LABEL",Val c.cx_def_label;
          "VARIABLE",Val (fst c.cx_variable ^ "_" ^ snd c.cx_variable);"POS",Val (string_of_int c.cx_pos);
          "RELATIONS",c.cx_relations;"CONTENTS",c.cx_contents]) (fun (e,t) ->
         e ^ ": " ^ (linear_term 0 t)))) ^ "]"
@@ -52,6 +52,7 @@ let rec linear_term c = function
   | SingleRelation r -> "singlerelation(" ^ linear_term 0 r ^ ")"
   (* | TripleRelation(r,a,c,t) -> "triplerelation(" ^ r ^ "," ^ a ^ "," ^ linear_term 0 c ^ "," ^ linear_term 0 t ^ ")" *)
   | AddRelation(t,r,a,s) -> "addrelation(" ^ linear_term 0 t ^ "," ^ r ^ "," ^ a ^ "," ^ linear_term 0 s ^ ")"
+  | AddSingleRelation(r,s) -> "addsinglerelation(" ^ linear_term 0 r ^ "," ^ linear_term 0 s ^ ")"
   | RemoveRelation(r,a,t) -> "removerelation(" ^ r ^ "," ^ a ^ "," ^ linear_term 0 t ^ ")"
   | SetContextName(s,t) -> "setcontextname(" ^ linear_term 0 s ^ "," ^ linear_term 0 t ^ ")"
   | CreateContext(s,t) -> "createcontext(" ^ linear_term 0 (Context s) ^ "," ^ linear_term 0 t ^ ")"
@@ -30,9 +30,9 @@ type node = {
   amorf: ENIAMwalTypes.morf;
   arole: string;
   arole_attr: string;
-  meaning: string;
+  sense: string;
   hipero: StringSet.t;
-  meaning_weight: float;
+  sense_weight: float;
     position: ENIAMwalTypes.schema_field;*)
   attrs: (string * linear_term) list;
   args: linear_term;
@@ -40,13 +40,14 @@ type node = {
   role: string;
   role_attr: string;
   selprefs: linear_term;
-  meaning: linear_term;
+  sense: linear_term;
   arole: string;
   arole_attr: string;
   arev: bool;
   sem_args: linear_term;
   label: string;
   def_label: string;
+  snode: string;
 }
  
 and concept =
@@ -57,7 +58,7 @@ and concept =
    c_pos: int; c_cat: linear_term}
  
 and context =
-  {cx_sense: linear_term; cx_contents: linear_term;
+  {cx_sense: linear_term; cx_contents: linear_term; cx_label: string; cx_def_label: string;
     cx_relations: linear_term; cx_variable: (string * string); cx_pos: int; cx_cat: linear_term}
  
 and linear_term =
@@ -72,9 +73,10 @@ and linear_term =
   | RevRelation of string * string * linear_term (* role * role_attr * concept *)
   | SingleRelation of linear_term
   (* | TripleRelation of string * string * linear_term * linear_term (* role * role_attr * concept *) *)
-  | AddRelation of linear_term * string * string * linear_term (* nadrządnik * role * role_attr * podrzędnik *)
+  | AddRelation of linear_term * string * string * linear_term (* nadrzędnik * role * role_attr * podrzędnik *)
+  | AddSingleRelation of linear_term * linear_term (* role * podrzędnik *)
   | RemoveRelation of string * string * linear_term
-  | SetContextName of linear_term * linear_term (* meaning * concept *)
+  | SetContextName of linear_term * linear_term (* sense * concept *)
   | CreateContext of context * linear_term (* context * args *)
   (* | MakeTripleRelation of string * string * linear_term (* role * role_attr * concept *) *)
   | ManageCoordination of node * linear_term
@@ -22,7 +22,7 @@ open ENIAM_LCGlexiconTypes
 open ENIAMlexSemanticsTypes
 open Xstd
  
-type pos = {role: linear_term; role_attr: linear_term; selprefs: linear_term; gf: ENIAMwalTypes.gf;
+type pos = {role: linear_term; role_attr: linear_term; selprefs: linear_term; catprefs: string list; gf: ENIAMwalTypes.gf;
   cr: string list; ce: string list;
   is_necessary: bool; is_pro: bool; is_prong: bool; is_multi: bool; dir: string; morfs: StringSet.t}
  
@@ -148,6 +148,8 @@ let rec apply_selector v2 chosen_map = function
   | Nsem,("NSEM",v) :: l -> match_value v2 chosen_map v
   | Case,("CASE",v) :: l -> match_value v2 chosen_map v
   | Mode,("MODE",v) :: l -> match_value v2 chosen_map v
+  | Acm,("ACM",v) :: l -> match_value v2 chosen_map v
+  | Cat,("CAT",v) :: l -> match_value v2 chosen_map v
   | sel,(attr,v) :: l -> (*print_endline ("apply_selector: " ^ ENIAMcategoriesPL.string_of_selector sel ^ " " ^ attr);*) apply_selector v2 chosen_map (sel,l)
  
 let rec apply_neg_selector vals chosen_map = function
@@ -218,7 +220,22 @@ let string_of_arg arg =
   String.concat ", " (Xlist.map arg (fun ((arg_symbol,dir),t) -> (string_of_argdir dir) ^ arg_symbol ^ ":" ^ ENIAM_LCGstringOf.linear_term 0 t))
  
 let string_of_position p =
-  (string_of_argdir p.dir) ^ String.concat "+" (StringSet.to_list p.morfs)
+  (string_of_argdir p.dir) ^
+  (if p.is_multi then "?" else "") ^
+  String.concat "+" (StringSet.to_list p.morfs)
+
+let manage_arg p t =
+  let t = SetAttr("gf",Val (ENIAMwalStringOf.gf p.gf),t) in
+  let t =
+    if p.gf = ENIAMwalTypes.SUBJ || p.gf = ENIAMwalTypes.OBJ || p.gf = ENIAMwalTypes.ARG then
+      SetAttr("role",p.role,SetAttr("role-attr",p.role_attr,SetAttr("selprefs",p.selprefs,t)))
+    else if p.gf = ENIAMwalTypes.CORE then SetAttr("selprefs",p.selprefs,t)
+    else if p.gf = ENIAMwalTypes.ADJUNCT || p.gf = ENIAMwalTypes.NOSEM || p.gf = ENIAMwalTypes.CORE then t
+    else failwith "manage_arg: ni 2" in
+  let t = Xlist.fold p.cr t (fun t cr -> SetAttr("controller",Val cr,t)) in
+  let t = Xlist.fold p.ce t (fun t ce -> SetAttr("controllee",Val ce,t)) in
+  let t = if p.gf = ENIAMwalTypes.NOSEM then Dot else t in
+  t
  
 let rec match_arg_positions lemma arg rev = function
     p :: positions ->
@@ -228,16 +245,13 @@ let rec match_arg_positions lemma arg rev = function
       (match l with
         [] -> (*print_endline "match_arg_positions: not matched";*) match_arg_positions lemma arg (p :: rev) positions
       | [t] ->
-          let t = SetAttr("gf",Val (ENIAMwalStringOf.gf p.gf),t) in
-          let t =
-            if p.gf = ENIAMwalTypes.SUBJ || p.gf = ENIAMwalTypes.OBJ || p.gf = ENIAMwalTypes.ARG then
-              SetAttr("role",p.role,SetAttr("role-attr",p.role_attr,SetAttr("selprefs",p.selprefs,t)))
-            else if p.gf = ENIAMwalTypes.CORE then SetAttr("selprefs",p.selprefs,t)
-            else if p.gf = ENIAMwalTypes.ADJUNCT || p.gf = ENIAMwalTypes.NOSEM || p.gf = ENIAMwalTypes.CORE then t
-            else failwith "match_arg_positions: ni 2" in
-          let t = Xlist.fold p.cr t (fun t cr -> SetAttr("controller",Val cr,t)) in
-          let t = Xlist.fold p.ce t (fun t ce -> SetAttr("controllee",Val ce,t)) in
-          let t = if p.gf = ENIAMwalTypes.NOSEM then Dot else t in
+          let t = manage_arg p t in
+          if p.is_multi then (t, rev @ (p :: positions)) :: (match_arg_positions lemma arg (p :: rev) positions)
+          else (t, rev @ positions) :: (match_arg_positions lemma arg (p :: rev) positions)
+      | [t1;t2] -> (* FIXME: przydałoby się to uogólnić na listę dowolnej długości *)
+          let t1 = manage_arg p t1 in
+          let t2 = manage_arg p t2 in
+          let t = Variant("",["1",t1;"2",t2]) in
           if p.is_multi then (t, rev @ (p :: positions)) :: (match_arg_positions lemma arg (p :: rev) positions)
           else (t, rev @ positions) :: (match_arg_positions lemma arg (p :: rev) positions)
       | _ -> failwith ("match_arg_positions: lemma=" ^ lemma ^ " arg=" ^ string_of_arg arg ^ " position=" ^ string_of_position p))
@@ -257,16 +271,17 @@ let rec match_args_positions_rec lemma prong_attrs positions = function
         [Xlist.fold positions [] (fun found p ->
           if not p.is_pro then found else
           let attrs = if p.is_prong then prong_attrs else [] in
-          let cats = p.selprefs(*ENIAM_LCGrules.make_variant (ENIAMwalRenderer.extract_sel_prefs p.sel_prefs)*) in
+          let cats = p.catprefs(*ENIAM_LCGrules.make_variant (ENIAMwalRenderer.extract_sel_prefs p.sel_prefs)*) in
           let lemma = get_pro_lemma attrs in
-          let attrs = ["CAT",cats;"PROJ",cats] @ attrs in
           let sem_args = try StringMap.find ENIAMlexSemanticsData.pron_sem_args lemma with Not_found -> failwith "match_args_positions_rec" in
-          let attrs = ["meaning",Val lemma;"hipero",Tuple[Val "ALL"; Val "0"];"role",p.role;
+          let attrs = ["sense",Val lemma;"hipero",Tuple[Val "ALL"; Val "0"];"role",p.role;
             "role-attr",p.role_attr; "selprefs",p.selprefs; "gf",Val (ENIAMwalStringOf.gf p.gf);
             "agf",Val ""; "sem-args",make_sem_args sem_args; "rev-hipero",Val "+"] @ attrs in
           let attrs = Xlist.fold p.cr attrs (fun attrs cr -> ("controller",Val cr) :: attrs) in
           let attrs = Xlist.fold p.ce attrs (fun attrs ce -> ("controllee",Val ce) :: attrs) in
-          Node{ENIAM_LCGrenderer.empty_node with lemma=lemma; pos="pro"; attrs=attrs} :: found)]
+          Xlist.fold cats found (fun found cat ->
+            let attrs = ["CAT",Val cat;"COERCED",Val cat] @ attrs in
+            Node{ENIAM_LCGrenderer.empty_node with lemma=lemma; pos="pro"; attrs=attrs} :: found))]
  
 (* FIXME: opcjonalność podrzędników argumentów zleksykalizowanych *)
  
@@ -314,6 +329,7 @@ let translate_position id p =
       [] -> Dot
     | [s] -> Val s
     | l -> Tuple(Xlist.rev_map l (fun s -> Val s)));
+   catprefs = p.ENIAMwalTypes.cat_prefs;
    gf=p.ENIAMwalTypes.gf;
    cr=Xlist.map p.ENIAMwalTypes.cr (fun cr -> id ^ "-" ^ cr);
    ce=Xlist.map p.ENIAMwalTypes.ce (fun ce -> id ^ "-" ^ ce);
@@ -369,17 +385,19 @@ let rec assign_frames_rec tokens lex_sems tree arg_symbols visited = function
           let frame = ENIAMsemLexicon.extend_frame phsymbol frame in
           (* print_endline "passed"; *)
           (attrs,symbol,frame,Xlist.rev_map frame.positions (translate_position (string_of_int t.id))) :: frames
-        with Not_found -> (*print_endline "rejected";*) frames) in
-      if frames = [] then failwith "assign_frames_rec: no frame" else
+        with Not_found ->
+          (* print_endline "rejected"; *)
+          frames) in
+      if frames = [] then failwith ("assign_frames_rec: no frame phsymbol='" ^ phsymbol ^ "' node='" ^ t.lemma ^ "'") else
       let prong_attrs = get_prong_attrs t.attrs in
       let e = ENIAM_LCGreductions.get_variant_label () in
       let l,_ = Xlist.fold frames ([],1) (fun (l,n) (attrs,symbol,frame,positions) ->
         (* Printf.printf "assign_frames_rec 3: lemma=%s args=[%s] positions=[%s]\n%!" t.lemma (String.concat "; " (Xlist.map args string_of_arg)) (String.concat "; " (Xlist.map positions string_of_position)); *)
-        if frame.meanings = [] then failwith ("assign_frames_rec: no meanings '" ^ t.lemma ^ "'") else
+        if frame.senses = [] then failwith ("assign_frames_rec: no senses '" ^ t.lemma ^ "'") else
         Xlist.fold (match_args_positions t.lemma prong_attrs args positions) (l,n) (fun (l,n) args ->
-          Xlist.fold frame.meanings (l,n) (fun (l,n) (meaning,hipero,weight) ->
+          Xlist.fold frame.senses (l,n) (fun (l,n) (sense,hipero,weight) ->
             (string_of_int n, Node{t with attrs=
-              ("meaning",Val meaning) ::
+              ("sense",Val sense) ::
               ("hipero",ENIAM_LCGrules.make_variant (Xlist.map hipero (fun (h,n) -> Tuple[Val h;Val(string_of_int n)]))) ::
               ("arole",Val frame.arole) ::
               ("arole-attr",Val frame.arole_attr) ::
@@ -390,7 +408,9 @@ let rec assign_frames_rec tokens lex_sems tree arg_symbols visited = function
               ("fopinion",Val (ENIAMwalStringOf.opinion frame.fopinion)) ::
               ("sopinion",Val (ENIAMwalStringOf.opinion frame.sopinion)) :: attrs; args=args; symbol=symbol}) ::
               l,n+1))) in
-      if l = [] then ((*print_endline ("assign_frames_rec 4: no frame assingment found for " ^ t.lemma ^ " " ^ ENIAM_LCGstringOf.linear_term 0 t.symbol);*)raise (NoFrame(t.lemma,ENIAM_LCGstringOf.linear_term 0 t.symbol,visited))) else
+      if l = [] then (
+        (* print_endline ("assign_frames_rec 4: no frame assingment found for " ^ t.lemma ^ " " ^ ENIAM_LCGstringOf.linear_term 0 t.symbol); *)
+        raise (NoFrame(t.lemma,ENIAM_LCGstringOf.linear_term 0 t.symbol,visited))) else
       Variant(e,l),visited
   | Variant(e,l) ->
       let a = ref "" in
@@ -36,7 +36,7 @@ let rec linear_term = function
          Xml.Element("attrs",[],Xlist.map t.attrs (fun (k,v) -> Xml.Element("attr",["name",k],[linear_term v])));
          Xml.Element("args",[],[linear_term t.args]);
          Xml.Element("selprefs",[],[linear_term t.selprefs]);
-         Xml.Element("meaning",[],[linear_term t.meaning]);
+         Xml.Element("sense",[],[linear_term t.sense]);
          Xml.Element("sem_args",[],[linear_term t.sem_args])])
   | Ref i -> Xml.Element("Ref",["index",string_of_int i],[])
   | Concept c ->
@@ -49,8 +49,8 @@ let rec linear_term = function
          Xml.Element("relations",[],[linear_term c.c_relations]);
          Xml.Element("cat",[],[linear_term c.c_cat])])
   | Context c ->
-      Xml.Element("Context",
-        ["variable",fst c.cx_variable ^ "_" ^ snd c.cx_variable;"pos",string_of_int c.cx_pos],
+      Xml.Element("Context",["label",c.cx_label;"def_label",c.cx_def_label;
+        "variable",fst c.cx_variable ^ "_" ^ snd c.cx_variable;"pos",string_of_int c.cx_pos],
         [Xml.Element("sense",[],[linear_term c.cx_sense]);
          Xml.Element("contents",[],[linear_term c.cx_contents]);
          Xml.Element("relations",[],[linear_term c.cx_relations]);
@@ -61,6 +61,9 @@ let rec linear_term = function
   | AddRelation(t,r,a,s) ->
       Xml.Element("AddRelation",["role",r;"role_attribute",a],
         [Xml.Element("",[],[linear_term t]);Xml.Element("",[],[linear_term s])])
+  | AddSingleRelation(r,s) ->
+      Xml.Element("AddSingleRelation",[],
+        [Xml.Element("",[],[linear_term r]);Xml.Element("",[],[linear_term s])])
   | RemoveRelation(r,a,t) -> Xml.Element("RemoveRelation",["role",r;"role_attribute",a],[linear_term t])
   | SetContextName(s,t) ->
       Xml.Element("SetContextName",[],[linear_term s;linear_term t])