diff --git a/LCGlexicon/ENIAM_LCGlexicon.ml b/LCGlexicon/ENIAM_LCGlexicon.ml
index 65b566a..9681ca4 100644
--- a/LCGlexicon/ENIAM_LCGlexicon.ml
+++ b/LCGlexicon/ENIAM_LCGlexicon.ml
@@ -152,55 +152,6 @@ let make_quantification e rules =
       let syntax = if bracket then ENIAM_LCGtypes.Bracket(true,true,syntax) else ENIAM_LCGtypes.Bracket(false,false,syntax) in
       cats,syntax,semantics)
 
-(***
-type rule2 =
-    Basic of string
-  | Quant of (selector * string) list * string
-  | Raised of (selector * string) list * string * selector list
-  | Quot of (selector * string) list * string
-  | Inclusion of string
-  | Conj of (selector * string) list * string
-  | Bracket of string
-
-
-
-let parse_quants_range quant =
-  Xlist.map quant (fun (cats,v) -> cats, parse_quant_range (cats,v))
-(**
-   let parse_rule categories = function
-    Basic syntax ->
-    let quant = parse_quants_range categories in
-    false, quant, parse_syntax syntax, BasicSem(Xlist.map quant fst)
-   | Quant(quant,syntax) ->
-    let quant = parse_quants_range (merge_quant categories quant) in
-    false, quant, parse_syntax syntax, BasicSem(Xlist.map quant fst)
-   | Raised(quant,syntax,semantics) ->
-    let quant = parse_quants_range (merge_quant categories quant) in
-    false, quant, parse_syntax syntax, RaisedSem(Xlist.map quant fst,semantics)
-   | Quot(quant,syntax) ->
-    let quant = parse_quants_range (merge_quant categories quant) in
-    false, quant, parse_syntax syntax, QuotSem(Xlist.map quant fst)
-   | Inclusion syntax ->
-    let quant = parse_quants_range categories in
-    false, quant, parse_syntax syntax, InclusionSem(Xlist.map quant fst)
-   | Conj(quant,syntax) ->
-    let quant = parse_quants_range (merge_quant categories quant) in
-    false, quant, parse_syntax syntax, ConjSem(Xlist.map quant fst)
-   | Bracket syntax ->
-    let quant = parse_quants_range categories in
-    true, quant, parse_syntax syntax, BasicSem(Xlist.map quant fst)
-
-   let parse_grammar grammar =
-   List.rev (Xlist.fold grammar [] (fun grammar (selectors,rule,weight) ->
-      let selectors = parse_selectors selectors in
-      let pos = find_selector Pos selectors in
-      let categories =
-        try StringMap.find pos_categories pos
-        with Not_found -> failwith ("parse_grammar: " ^ pos) in
-      let rule = try parse_rule categories rule with Not_found -> failwith ("parse_grammar: " ) in
-      (selectors,rule,weight) :: grammar))
- **)
-
 (* let translate_negation = function
     (Negation:negation) -> ["neg"]
    | Aff -> ["aff"]
@@ -231,8 +182,8 @@ let parse_quants_range quant =
    | GerAtrs(m,le,neg,a) -> [Negation,Eq,translate_negation neg;Aspect,Eq,translate_aspect a]
    | NonPersAtrs(m,le,role,role_attr,neg,a) -> [Negation,Eq,translate_negation neg;Aspect,Eq,translate_aspect a]
    | ComprepAtrs _ -> failwith "apply_valence_selectors" *)
- ***)
-(* FIXME: argumenty X i raised i inne *)
+
+(* FIXME: argumenty X  *)
 
 (* let render_schema schema =
    Xlist.map schema (function
@@ -253,11 +204,12 @@ let parse_quants_range quant =
             | _ -> l)
       else (cats,(bracket,quant,syntax,semantics),weight) :: l) *)
 
-(* FIXME: ustawienie wartości symbol *)
 (* FIXME: problem z atrybutami przy zamianie kolejności rzędników *)
 let make_node id orth lemma pos syntax weight cat_list is_raised =
-  let attrs = Xlist.fold cat_list(*Xlist.rev_map quant fst*) [] (fun attrs -> function
+  let attrs = Xlist.fold cat_list [] (fun attrs -> function
       | Lemma -> attrs
+      | Pos -> attrs
+      | Pos2 -> attrs
       | Cat -> ("CAT",SubstVar "cat") :: attrs
       | Number -> ("NUM",SubstVar "number") :: attrs
       | Case -> ("CASE",SubstVar "case") :: attrs
@@ -273,7 +225,16 @@ let make_node id orth lemma pos syntax weight cat_list is_raised =
       | Nsyn -> ("NSYN", SubstVar "nsyn") :: attrs
       | Nsem -> ("NSEM", SubstVar "nsem") :: attrs
       | Ctype -> ("CTYPE", SubstVar "ctype") :: attrs
-      | s -> (string_of_selector s, Dot) :: attrs) in
+      | Inumber -> attrs
+      | Igender -> attrs
+      | Iperson -> attrs
+      | Nperson -> attrs
+      | Plemma -> attrs
+      | Unumber -> attrs
+      | Ucase -> attrs
+      | Ugender -> attrs
+      | Uperson -> 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
diff --git a/LCGlexicon/resources/lexicon-pl.dic b/LCGlexicon/resources/lexicon-pl.dic
index 09d2f10..a2b40a8 100644
--- a/LCGlexicon/resources/lexicon-pl.dic
+++ b/LCGlexicon/resources/lexicon-pl.dic
@@ -137,13 +137,13 @@ pos=adv: advp{schema}{\(1+qub),/(1+inclusion)}{\(1+adja)};
 # FIXME: dwa znaczenia jak: pytanie o cechę lub spójnik
 lemma=jak|skąd|dokąd|gdzie|którędy|kiedy,pos=adv:
   QUANT[inumber=0,igender=0,iperson=0,ctype=int&rel] RAISED[ctype]
-  cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)};
 lemma=odkąd|dlaczego|czemu,pos=adv:
   QUANT[inumber=0,igender=0,iperson=0,ctype=int] RAISED[ctype]
-  cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)};
 lemma=gdy,pos=adv:
   QUANT[inumber=0,igender=0,iperson=0,ctype=sub] RAISED[ctype]
-  cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{\(1+advp),/(ip*inumber*igender*iperson/advp)};
 
 # czasowniki
 pos=ger:  np*number*case*gender*person{schema}{\(1+qub),/(1+inclusion)};
@@ -195,42 +195,50 @@ pos=pant,negation=neg:  padvp{schema}{\(1+qub),/(1+inclusion)}{\nie};
 
 pos=comp:               QUANT[ctype=sub] cp*ctype*lemma/ip*T*T*T;
 pos=conj:               QUANT[ctype=coord] cp*ctype*lemma/ip*T*T*T;
-#lemma=i|lub|czy|bądź,pos=conj:   Conj([number=all_numbers,gender=all_genders,person=all_persons],"(ip*number*gender*person/ip*T*T*T)\ip*T*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/prepnp*T*T)\prepnp*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/advp)\prepnp*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/prepnp*T*T)\advp"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([],"(advp/advp)\advp"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([plemma=0,case=all_cases],"(prepnp*plemma*case/prepnp*plemma*case)\prepnp*plemma*case"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([number=all_numbers,case=all_cases,gender=all_genders,person=all_persons],"(np*number*case*gender*person/np*T*case*T*T)\np*T*case*T*T"),0.;
-#lemma=,|i|lub|czy|bądź,pos=conj: Conj([number=all_numbers,case=all_cases,gender=all_genders],"(adjp*number*case*gender/adjp*number*case*gender)\adjp*number*case*gender"),0.;
+lemma=i|lub|czy|bądź,pos=conj:
+  QUANT[number=all_numbers,gender=all_genders,person=all_persons]
+  (ip*number*gender*person/ip*T*T*T)\ip*T*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/prepnp*T*T)\prepnp*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/advp)\prepnp*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/prepnp*T*T)\advp;
+lemma=,|i|lub|czy|bądź,pos=conj: (advp/advp)\advp;
+lemma=,|i|lub|czy|bądź,pos=conj:
+  QUANT[plemma=0,case=all_cases]
+  (prepnp*plemma*case/prepnp*plemma*case)\prepnp*plemma*case;
+lemma=,|i|lub|czy|bądź,pos=conj:
+  QUANT[number=all_numbers,case=all_cases,gender=all_genders,person=all_persons]
+  (np*number*case*gender*person/np*T*case*T*T)\np*T*case*T*T;
+lemma=,|i|lub|czy|bądź,pos=conj:
+  QUANT[number=all_numbers,case=all_cases,gender=all_genders]
+  (adjp*number*case*gender/adjp*number*case*gender)\adjp*number*case*gender;
 
 lemma=co|kto,pos=subst:
   QUANT[inumber=0,igender=0,iperson=0,ctype=int&rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
-  cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person); #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person);
 lemma=co|kto,pos=subst:
   QUANT[inumber=0,igender=0,iperson=0,plemma=0,ctype=int&rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
-  cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case),/(prepnp*plemma*case/np*number*case*gender*person)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case),/(prepnp*plemma*case/np*number*case*gender*person)};
 lemma=to,pos=subst:
   QUANT[ctype=0,plemma=0,number=T,case=T,gender=T,person=ter]
   ncp*number*case*gender*person*ctype*plemma{\(1+qub),/(1+inclusion)}{/cp*ctype*plemma};
 pos=ppron3,praep=praep:
   QUANT[plemma=0,number=T,case=T,gender=T,person=T] RAISED[]
-  prepnp*plemma*case\(prepnp*plemma*case/np*number*case*gender*person); #inclusion #[Number;Case;Gender;Person];
+  prepnp*plemma*case\(prepnp*plemma*case/np*number*case*gender*person); #inclusion #[Number;Case;Gender;Person]; #FIXME: semantyka
 lemma=ile,pos=num:  # FIXME: iloma ma bezpośredni podrzędnik rzeczownikowy, a ile nie # FIXME: mwe "o ile, na ile"
   QUANT[inumber=0,igender=0,iperson=0,ctype=int&rel,number=T,case=T,gender=T,person=ter]
-  cp*ctype*lemma/ip*inumber*igender*iperson; # FIXME: zaślepka, bo podrzędnik ile nie musi z nim sąciadować  #["CTYPE",SubstVar "ctype"] # FIXME: trzeba dodać przypadki, bezpośredniego podrzędnika rzeczownikowego i przyimka nad "ile"
+  cp*ctype*lemma/ip*inumber*igender*iperson; # FIXME: zaślepka, bo podrzędnik ile nie musi z nim sąciadować  # FIXME: trzeba dodać przypadki, bezpośredniego podrzędnika rzeczownikowego i przyimka nad "ile"
 lemma=czyj|jaki|który,pos=apron:
   QUANT[inumber=0,igender=0,iperson=0,nperson=0,ctype=int,number=T,case=T,gender=T] RAISED[ctype]
-  cp*ctype*lemma{/(ip*inumber*igender*iperson/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{/(ip*inumber*igender*iperson/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)};
 lemma=czyj|jaki|który,pos=apron:
   QUANT[inumber=0,igender=0,iperson=0,nperson=0,plemma=0,ctype=int,number=T,case=T,gender=T] RAISED[ctype]
-  cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*nperson)}{/(np*number*case*gender*nperson\adjp*number*case*gender)};
 lemma=czyj|jaki,pos=apron:
   QUANT[inumber=0,igender=0,iperson=0,ctype=rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
-  cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person); #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma/(ip*inumber*igender*iperson/np*number*case*gender*person);
 lemma=jaki|który,pos=apron:
   QUANT[inumber=0,igender=0,iperson=0,plemma=0,ctype=rel,number=T,case=T,gender=T,person=ter] RAISED[ctype]
-  cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*person)}; #["CTYPE",SubstVar "ctype"]
+  cp*ctype*lemma{/(ip*inumber*igender*iperson/prepnp*plemma*case)}{/(prepnp*plemma*case/np*number*case*gender*person)};
 
 lemma=się,pos=qub:        się; # FIXME: dodać make_np
 lemma=nie,pos=qub:        nie;
@@ -245,14 +253,14 @@ pos=qub:                  qub;
 pos=interj:               interj;
 lemma=-,pos=interp:       hyphen;
 lemma=?,pos=interp:       int;
-#lemma=„,pos=interp:       Quot([number=0,case=0,gender=0,person=0],"(np*number*case*gender*person/rquot)/np*number*case*gender*person"),0.;
-#lemma=«,pos=interp:       Quot([number=0,case=0,gender=0,person=0],"(np*number*case*gender*person/rquot2)/np*number*case*gender*person"),0.;
-#lemma=»,pos=interp:       Quot([number=0,case=0,gender=0,person=0],"(np*number*case*gender*person/rquot3)/np*number*case*gender*person"),0.;
+lemma=„,pos=interp:       QUANT[number=0,case=0,gender=0,person=0] (np*number*case*gender*person/rquot)/np*number*case*gender*person; #SetAttr("QUOT",Val "+",Var "x"
+lemma=«,pos=interp:       QUANT[number=0,case=0,gender=0,person=0] (np*number*case*gender*person/rquot2)/np*number*case*gender*person; #SetAttr("QUOT",Val "+",Var "x"
+lemma=»,pos=interp:       QUANT[number=0,case=0,gender=0,person=0] (np*number*case*gender*person/rquot3)/np*number*case*gender*person; #SetAttr("QUOT",Val "+",Var "x"
 lemma=”,pos=interp:       rquot;
 lemma=»,pos=interp:       rquot2;
 lemma=«,pos=interp:       rquot3;
-#lemma=(,pos=interp:       Inclusion "(inclusion/rparen)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T);
-#lemma=[,pos=interp:       Inclusion "(inclusion/rparen2)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T);
+lemma=(,pos=interp:       (inclusion/rparen)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T); #SetAttr("INCLUSION",Val "+",
+lemma=[,pos=interp:       (inclusion/rparen2)/(np*T*T*T*T+ip*T*T*T+adjp*T*T*T+prepnp*T*T); #SetAttr("INCLUSION",Val "+",
 lemma=),pos=interp:       rparen;
 lemma=],pos=interp:       rparen2;
 pos=unk:                  np*number*case*gender*person;
@@ -273,7 +281,7 @@ lemma=:,pos=interp:               BRACKET or;
 lemma=:s,pos=interp:              BRACKET <colon>\<speaker>;
 lemma=:s,pos=interp:              BRACKET (<colon>\<speaker>)/<squery>;
 lemma=<or-sentence>,pos=interp:   BRACKET <root>/s;
-lemma=<or-sentence>,pos=interp:   BRACKET ((<root>/<speaker-end>)/(ip*T*T*T/or))/or2;
+lemma=<or-sentence>,pos=interp:   BRACKET ((<root>/<speaker-end>)/(ip*T*T*T/or))/or2; #FIXME: semantyka
 lemma=</or-sentence>,pos=interp:  BRACKET or2\?(ip*T*T*T+cp*int*T+np*sg*voc*T*T+interj);
 lemma=<sentence>,pos=interp:      BRACKET (<speaker>/<speaker-end>)/np*T*nom*T*T;
 lemma=</sentence>,pos=interp:     BRACKET <speaker-end>;
diff --git a/LCGlexicon/test.ml b/LCGlexicon/test.ml
index f9d7745..1666012 100644
--- a/LCGlexicon/test.ml
+++ b/LCGlexicon/test.ml
@@ -43,7 +43,7 @@ let examples = [
     8, 5, 6, "","</clause>","interp",     [],false;
     9, 6, 7, ".","</sentence>","interp",  [],false;
   ],7;*)
-  "jaki",[
+  (* "jaki",[
     1, 0, 1, "","<sentence>","interp",    [],false;
     2, 1, 2, "","<clause>","interp",      [],false;
     3, 2, 3,  "Jakiego","jaki","adj",     [["sg"];["gen";"acc"];["m1";"m2"];["pos"]],false;
@@ -53,7 +53,29 @@ let examples = [
     7, 6, 7, "?","?","interp",            [],false;
     8, 7, 8, "","</clause>","interp",     [],false;
     9, 8, 9, ".","</sentence>","interp",  [],false;
-  ],9;
+  ],9; *)
+  (*"kot_i_pies",[
+    1, 0, 1, "","<sentence>","interp",    [],false;
+    2, 1, 2, "","<clause>","interp",      [],false;
+    3, 2, 3, "Ala","Ala","subst",         [["sg"];["nom"];["f"]],true;
+    4, 3, 4, "ma","mieć","fin",           [["sg"];["ter"];["imperf"]],false;
+    5, 4, 5, "kota","kot","subst",        [["sg"];["gen";"acc"];["m1";"m2"]],false;
+    6, 5, 6, "i","i","conj",              [],false;
+    7, 6, 7, "psa","pies","subst",        [["sg"];["gen";"acc"];["m2"]],false;
+    8, 7, 8, "","</clause>","interp",     [],false;
+    9, 8, 9, ".","</sentence>","interp",  [],false;
+    ],9;*)
+"kotx",[
+    1, 0, 1, "","<sentence>","interp",    [],false;
+    2, 1, 2, "","<clause>","interp",      [],false;
+    3, 2, 3, "Ala","Ala","subst",         [["sg"];["nom"];["f"]],true;
+    4, 3, 4, "ma","mieć","fin",           [["sg"];["ter"];["imperf"]],false;
+    5, 4, 5, "„","„","interp",            [],false;
+    6, 5, 6, "kota","kot","subst",        [["sg"];["gen";"acc"];["m1";"m2"]],false;
+    7, 6, 7, "”","”","interp",            [],false;
+    8, 7, 8, "","</clause>","interp",     [],false;
+    9, 8, 9, ".","</sentence>","interp",  [],false;
+],9;
 ]
 
 let valence = [
@@ -64,6 +86,7 @@ let valence = [
                                                      Both,Plus[One;Tensor[Atom "np";Top;Atom "gen";Top;Top]]];
   [Lemma,Eq,["kot"];Pos,Eq,["subst"]],[Both,Plus[One;Tensor[Atom "adjp";AVar "number";AVar "case";AVar "gender"]]];
   [Lemma,Eq,["kota"];Pos,Eq,["subst"]],[];
+  [Lemma,Eq,["pies"];Pos,Eq,["subst"]],[];
 ]
 
 let create_chart valence tokens last =
diff --git a/LCGparser/ENIAM_LCGgraphOf.ml b/LCGparser/ENIAM_LCGgraphOf.ml
index deea1e8..6cd0424 100644
--- a/LCGparser/ENIAM_LCGgraphOf.ml
+++ b/LCGparser/ENIAM_LCGgraphOf.ml
@@ -30,7 +30,7 @@ let escape_string s =
 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);"WEIGHT",Val (string_of_float t.weight);
-    "SYMBOL",t.symbol;"ARG_SYMBOL",t.arg_symbol] @ t.attrs in
+    "SYMBOL",t.symbol;"ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir] @ t.attrs in
   "{ " ^ String.concat " | " (Xlist.map l (fun (e,t) -> "{ " ^ e ^ " | " ^ escape_string (ENIAM_LCGstringOf.linear_term 0 t) ^ " }")) ^ " }"
 
 
diff --git a/LCGparser/ENIAM_LCGlatexOf.ml b/LCGparser/ENIAM_LCGlatexOf.ml
index e820aa5..121b1a6 100644
--- a/LCGparser/ENIAM_LCGlatexOf.ml
+++ b/LCGparser/ENIAM_LCGlatexOf.ml
@@ -73,7 +73,7 @@ let rec linear_term c = function
     "{\\left[\\begin{array}{ll}" ^
     (String.concat "\\\\ " (Xlist.map (["ORTH",Val t.orth;"LEMMA",Val t.lemma;"POS",Val t.pos;"ID",Val (string_of_int t.id);
                                         "WEIGHT",Val (string_of_float t.weight);"SYMBOL",t.symbol;
-                                        "ARG_SYMBOL",t.arg_symbol;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
+                                        "ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
          "\\text{" ^ (Xlatex.escape_string e) ^ "} & " ^ (linear_term 0 t)))) ^ "\\end{array}\\right]}"
   (* | Morf m -> "\\text{" ^ Xlatex.escape_string (ENIAMwalStringOf.morf m) ^ "}"
   | Gf s -> "\\text{" ^ Xlatex.escape_string (ENIAMwalStringOf.gf s) ^ "}" *)
diff --git a/LCGparser/ENIAM_LCGreductions.ml b/LCGparser/ENIAM_LCGreductions.ml
index 83d02db..789b3e9 100644
--- a/LCGparser/ENIAM_LCGreductions.ml
+++ b/LCGparser/ENIAM_LCGreductions.ml
@@ -226,6 +226,7 @@ let linear_term_beta_reduction4 references =
            | "MORF",Morf morf -> Node{t with amorf=morf}
            | "AROLE",Val arole ->  Node{t with arole=arole} *)
            | "ARG_SYMBOL",symbol ->  Node{t with arg_symbol=symbol}
+           | "ARG_DIR",Val dir ->  Node{t with arg_dir=dir}
            | _ -> Node{t with attrs=(e,linear_term_beta_reduction subst s) :: t.attrs})
        | Variant(e2,l) -> Variant(e2,Xlist.map l (fun (i,t) -> i,linear_term_beta_reduction subst (SetAttr(e,s,t))))
        | t -> SetAttr(e,s,t))
diff --git a/LCGparser/ENIAM_LCGrenderer.ml b/LCGparser/ENIAM_LCGrenderer.ml
index b0cbc2f..5f792c2 100644
--- a/LCGparser/ENIAM_LCGrenderer.ml
+++ b/LCGparser/ENIAM_LCGrenderer.ml
@@ -95,7 +95,7 @@ let rec substitute_substvar v g = function
 
 
 let empty_node = {
-  orth=""; lemma=""; pos=""; weight=0.; id=0; symbol=Dot; arg_symbol=Dot; attrs=[]; args=Dot;}
+  orth=""; lemma=""; pos=""; weight=0.; id=0; symbol=Dot; arg_symbol=Dot; arg_dir=""; attrs=[]; args=Dot;}
 
 let variable_num_ref = ref 0
 
@@ -126,13 +126,21 @@ let make_arg_symbol l =
       | Top -> Val "T"
       | _ -> failwith "make_arg_symbol"))
 
-let rec make_term_arg = function
-    Tensor l -> let v = get_variable_name () in v, Cut(SetAttr("ARG_SYMBOL",make_arg_symbol l,Var v))
-  | Plus l -> let v = get_variable_name () in v, Case(Var v,Xlist.map l make_term_arg)
+let string_of_direction = function
+    Forward -> "forward"
+  | Backward -> "backward"
+  | Both -> "both"
+
+let rec make_term_arg dir = function
+    Tensor l ->
+    let v = get_variable_name () in
+    v, Cut(SetAttr("ARG_DIR",Val (string_of_direction dir),
+                   SetAttr("ARG_SYMBOL",make_arg_symbol l,Var v)))
+  | Plus l -> let v = get_variable_name () in v, Case(Var v,Xlist.map l (make_term_arg dir))
   (* | Imp(s,d,t2) -> *)
   | One -> get_variable_name (), Dot
   | Maybe s ->
-    let v,arg = make_term_arg s in
+    let v,arg = make_term_arg dir s in
     let w = get_variable_name () in
     w, Fix(Var w,Lambda(v,arg))
   | _ -> failwith "make_term_arg"
@@ -165,11 +173,11 @@ let is_raised = function
 let rec make_term_imp node outer_node = function
   | Imp(s,d,t2) ->
     if is_raised [d,t2] then make_raised_term_imp (Node node) outer_node Dot (Imp(s,d,t2)) else
-    let v,arg = make_term_arg t2 in
+    let v,arg = make_term_arg d t2 in
     Lambda(v,make_term_imp (add_args node [arg]) outer_node s)
   | ImpSet(s,l) ->
     if is_raised l then make_raised_term_imp (Node node) outer_node Dot (ImpSet(s,l)) else
-    let vars,args = List.split (Xlist.map l (fun (_,t) -> make_term_arg t)) in
+    let vars,args = List.split (Xlist.map l (fun (d,t) -> make_term_arg d t)) in
     LambdaSet(vars,make_term_imp (add_args node args) outer_node s)
   | Tensor l -> Node node
   | _ -> failwith "make_term_imp"
diff --git a/LCGparser/ENIAM_LCGstringOf.ml b/LCGparser/ENIAM_LCGstringOf.ml
index 572eb29..3f5d082 100644
--- a/LCGparser/ENIAM_LCGstringOf.ml
+++ b/LCGparser/ENIAM_LCGstringOf.ml
@@ -56,7 +56,7 @@ let rec linear_term c = function
     "[" ^
     (String.concat "; " (Xlist.map (["ORTH",Val t.orth;"LEMMA",Val t.lemma;"POS",Val t.pos;"ID",Val (string_of_int t.id);
                                      "WEIGHT",Val (string_of_float t.weight);"SYMBOL",t.symbol;
-                                     "ARG_SYMBOL",t.arg_symbol;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
+                                     "ARG_SYMBOL",t.arg_symbol;"ARG_DIR",Val t.arg_dir;"ARGS",t.args] @ t.attrs) (fun (e,t) ->
          e ^ ": " ^ (linear_term 0 t)))) ^ "]"
 (*  | Morf m -> ENIAMwalStringOf.morf m
     | Gf s -> ENIAMwalStringOf.gf s*)
diff --git a/LCGparser/ENIAM_LCGtypes.ml b/LCGparser/ENIAM_LCGtypes.ml
index 2f87a6b..5170ed7 100644
--- a/LCGparser/ENIAM_LCGtypes.ml
+++ b/LCGparser/ENIAM_LCGtypes.ml
@@ -31,6 +31,7 @@ type node = {
   id: int;
   symbol: linear_term;
   arg_symbol: linear_term;
+  arg_dir: string;
   (*agf: ENIAMwalTypes.gf;
   amorf: ENIAMwalTypes.morf;
   arole: string;