Initial commit: parser for tiny subset of SCADE language...

14 files changed, 3492 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..ca7415d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+*.swp
+_build
+analyze
+*~
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..5e785e0
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,21 @@
+.PHONY: clean
+
+BIN=analyze
+SRCDIRS=libs,frontend
+
+SRC= 	main.ml \
+		frontend/ast.ml \
+		frontend/parser.mly \
+		frontend/lexer.mll \
+		frontend/ast_printer.ml
+
+all: $(BIN)
+
+$(BIN): $(SRC)
+	ocamlbuild -Is $(SRCDIRS) -cflags '-I +zarith -I +apron -I +gmp' \
+			-lflags '-I +zarith -I +apron -I +gmp zarith.cmxa bigarray.cmxa gmp.cmxa apron.cmxa polkaMPQ.cmxa' \
+		    main.native
+	mv main.native $(BIN)
+
+clean:
+	rm -rf _build
diff --git a/_tags b/_tags
new file mode 100644
index 0000000..25bfa60
--- /dev/null
+++ b/_tags
@@ -0,0 +1 @@
+true: use_menhir
diff --git a/frontend/ast.ml b/frontend/ast.ml
new file mode 100644
index 0000000..180608c
--- /dev/null
+++ b/frontend/ast.ml
@@ -0,0 +1,76 @@
+open Lexing
+
+type position = Lexing.position
+let position_unknown = Lexing.dummy_pos
+
+type extent = position * position
+let extent_unknown = (position_unknown, position_unknown)
+
+type 'a ext = 'a * extent
+
+type id = string
+
+type typ =
+    | AST_TINT
+    | AST_TBOOL
+    | AST_TREAL
+
+type unary_op =
+    | AST_UPLUS
+    | AST_UMINUS
+    | AST_NOT
+    | AST_PRE
+
+type binary_op =
+    | AST_PLUS
+    | AST_MINUS
+    | AST_MUL
+    | AST_DIV
+    | AST_MOD
+
+    | AST_EQ
+    | AST_NE
+
+    | AST_LT
+    | AST_LE
+    | AST_GT
+    | AST_GE
+
+    | AST_AND
+    | AST_OR
+
+    | AST_ARROW
+
+type expr =
+    | AST_unary of unary_op * (expr ext)
+    | AST_binary of binary_op * (expr ext) * (expr ext)
+    | AST_identifier of id ext
+    | AST_int_const of string ext
+    | AST_bool_const of bool
+    | AST_real_const of string ext
+    | AST_if of (expr ext) * (expr ext) * (expr ext)
+    | AST_instance of (id ext) * (expr ext list)
+
+type lvalue = id
+
+type eqn =
+    | AST_assign of (lvalue ext) * (expr ext)
+    | AST_guarantee of (id ext) * (expr ext)
+    | AST_assume of (id ext) * (expr ext)
+    (* and more : automaton, activate... *)
+
+type node_decl = {
+    name : id;
+    args : (bool * (id ext) * typ) list;
+    ret : (bool * (id ext) * typ) list;
+    var : (bool * (id ext) * typ) list;
+    body : eqn ext list;
+}
+
+type const_decl = (id ext) * typ * (expr ext)
+
+type toplevel =
+    | AST_node_decl of node_decl ext
+    | AST_const_decl of const_decl ext
+
+type prog = toplevel list
diff --git a/frontend/ast_printer.ml b/frontend/ast_printer.ml
new file mode 100644
index 0000000..a02b970
--- /dev/null
+++ b/frontend/ast_printer.ml
@@ -0,0 +1,177 @@
+open Ast
+open Lexing
+
+
+(* Locations *)
+
+let string_of_position p =
+  Printf.sprintf "%s:%i:%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol)
+    
+let string_of_extent (p,q) =
+  if p.pos_fname = q.pos_fname then
+    if p.pos_lnum = q.pos_lnum then
+      if p.pos_cnum = q.pos_cnum then
+        Printf.sprintf "%s:%i.%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol)
+      else
+        Printf.sprintf "%s:%i.%i-%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) (q.pos_cnum - q.pos_bol)
+    else
+      Printf.sprintf "%s:%i.%i-%i.%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) q.pos_lnum (q.pos_cnum - q.pos_bol)
+  else
+    Printf.sprintf "%s:%i.%i-%s:%i.%i" p.pos_fname p.pos_lnum (p.pos_cnum - p.pos_bol) q.pos_fname q.pos_lnum (q.pos_cnum - q.pos_bol)
+
+
+(* Operators *)
+
+let string_of_unary_op = function
+  | AST_UPLUS -> "+"
+  | AST_UMINUS -> "-"
+  | AST_NOT -> "not"
+  | AST_PRE -> "pre"
+
+let string_of_binary_op = function
+  | AST_MUL -> "*"
+  | AST_DIV -> "/"
+  | AST_MOD -> "mod"
+  | AST_PLUS -> "+"
+  | AST_MINUS -> "-"
+  | AST_EQ -> "="
+  | AST_NE -> "<>"
+  | AST_LT -> "<"
+  | AST_LE -> "<="
+  | AST_GT -> ">"
+  | AST_GE -> ">="
+  | AST_AND -> "and"
+  | AST_OR -> "or"
+  | AST_ARROW -> "->"
+
+
+let binary_precedence = function
+  | AST_MUL| AST_DIV| AST_MOD-> 7
+  | AST_PLUS  | AST_MINUS -> 6
+  | AST_EQ | AST_NE -> 5
+  | AST_LT | AST_LE | AST_GT | AST_GE -> 4
+  | AST_AND -> 3
+  | AST_OR -> 2
+  | AST_ARROW -> 1
+
+let expr_precedence = function
+  | AST_unary (op, _) -> 99
+  | AST_binary(op, _, _) -> binary_precedence op
+  | _ -> 100
+
+(* utility *)
+
+let print_list f sep fmt l =
+  let rec aux = function
+    | [] -> ()
+    | [a] -> f fmt a
+    | a::b -> f fmt a; Format.pp_print_string fmt sep; aux b
+  in
+  aux l
+
+(* types *)
+
+let string_of_typ = function
+  | AST_TINT -> "int"
+  | AST_TBOOL -> "bool"
+  | AST_TREAL -> "real"
+
+(* expressions *)
+
+let print_id fmt v =
+  Format.pp_print_string fmt v
+
+let rec print_expr fmt e = 
+  match e with
+    
+  | AST_unary (op,(e1,_)) ->
+      Format.pp_print_string fmt (string_of_unary_op op);
+      if expr_precedence e1 <= expr_precedence e
+      then Format.fprintf fmt " (%a)" print_expr e1
+      else Format.fprintf fmt " %a" print_expr e1
+
+  | AST_binary (op,(e1,_),(e2,_)) ->
+      if expr_precedence e1 < expr_precedence e
+      then Format.fprintf fmt "(%a) " print_expr e1
+      else Format.fprintf fmt "%a " print_expr e1;
+      Format.pp_print_string fmt (string_of_binary_op op);
+      if expr_precedence e2 <= expr_precedence e
+      then Format.fprintf fmt " (%a)" print_expr e2
+      else Format.fprintf fmt " %a" print_expr e2
+
+  | AST_int_const (i,_) -> Format.pp_print_string fmt i
+
+  | AST_real_const (i,_) -> Format.pp_print_string fmt i
+
+  | AST_bool_const b -> Format.pp_print_bool fmt b
+
+  | AST_if((c,_), (t,_), (e,_)) -> Format.fprintf fmt
+    "if %a then %a else %a"
+    print_expr c print_expr t print_expr e
+        
+  | AST_identifier (v,_) -> print_id fmt v
+
+  | AST_instance ((i,_),l) ->
+      Format.fprintf fmt "%a(%a)"
+        print_id i (print_list print_expr ",") (List.map fst l)
+
+let print_lvalue fmt v =
+  Format.pp_print_string fmt v
+
+(* equations *)
+
+let indent ind = ind^"  "
+
+let rec print_eqn ind fmt = function
+
+  | AST_assign ((v,_),(e,_)) ->
+      Format.fprintf fmt "%s%a = %a;@\n" 
+        ind print_lvalue v print_expr e
+  | AST_assume((i, _), (e, _)) ->
+    Format.fprintf fmt "%sassume %s : %a;@\n"
+        ind i print_expr e
+  | AST_guarantee((i, _), (e, _)) ->
+    Format.fprintf fmt "%sguarantee %s : %a;@\n"
+        ind i print_expr e
+
+and print_block ind fmt b =
+  List.iter (fun (bb,_) -> print_eqn (indent ind) fmt bb) b
+
+(* declarations *)
+
+let print_var_decl fmt (pr, (i, _), ty) =
+    Format.fprintf fmt "%s%s: %s"
+        (if pr then "probe " else "")
+        i
+        (string_of_typ ty)
+
+let rec print_var_decls fmt = function
+    | [] -> ()
+    | [a] -> print_var_decl fmt a
+    | a::r ->
+        print_var_decl fmt a;
+        Format.fprintf fmt "; ";
+        print_var_decls fmt r
+
+let print_node_decl fmt d =
+    Format.fprintf fmt "node %s(%a) returns(%a)@\n"
+        d.name
+        print_var_decls d.args
+        print_var_decls d.ret;
+    if d.var <> [] then
+        Format.fprintf fmt "var %a@\n" print_var_decls d.var;
+    Format.fprintf fmt "let@\n%atel@\n@\n"
+        (print_block "") d.body
+
+let print_const_decl fmt ((i, _), ty, (e, _)) =
+    Format.fprintf fmt
+        "const %s: %s = %a@\n@\n"
+        i (string_of_typ ty)
+        print_expr e
+
+let print_toplevel fmt = function
+    | AST_node_decl (n, _) -> print_node_decl fmt n
+    | AST_const_decl (c, _) -> print_const_decl fmt c
+
+let print_prog fmt p =
+    List.iter (print_toplevel fmt) p
diff --git a/frontend/file_parser.ml b/frontend/file_parser.ml
new file mode 100644
index 0000000..0e975ce
--- /dev/null
+++ b/frontend/file_parser.ml
@@ -0,0 +1,19 @@
+open Ast
+open Ast_printer
+open Lexing
+
+let parse_file (filename : string) : prog =
+    let f = open_in filename in
+    let lex = from_channel f in
+    try
+        lex.lex_curr_p <- { lex.lex_curr_p with pos_fname = filename; };
+        Parser.file Lexer.token lex
+    with
+    | Parser.Error ->
+        Printf.eprintf "Parse error (invalid syntax) near %s\n"
+            (string_of_position lex.lex_start_p);
+        failwith "Parse error"
+    | Failure "lexing: empty token" ->
+        Printf.eprintf "Parse error (invalid token) near %s\n"
+            (string_of_position lex.lex_start_p);
+        failwith "Parse error"
diff --git a/frontend/lexer.mll b/frontend/lexer.mll
new file mode 100644
index 0000000..9d6c208
--- /dev/null
+++ b/frontend/lexer.mll
@@ -0,0 +1,105 @@
+{
+    open Lexing
+    open Ast
+    open Parser
+
+    let kwd_table = Hashtbl.create 10
+    let () =
+        List.iter (fun (a, b) -> Hashtbl.add kwd_table a b)
+        [
+            "bool",     BOOL;
+            "int",      INT;
+            "real",     REAL;
+
+            "const",    CONST;
+            "node",     NODE;
+            "returns",  RETURNS;
+            "var",      VAR;
+            "let",      LET;
+            "tel",      TEL;
+
+            "if",       IF;
+            "then",     THEN;
+            "else",     ELSE;
+            "pre",      PRE;
+            "not",      NOT;
+            "and",      AND;
+            "or",       OR;
+            "mod",      MOD;
+
+            "true",     TRUE;
+            "false",    FALSE;
+
+            "assume",   ASSUME;
+            "guarantee",GUARANTEE;
+            "probe",    PROBE;
+        ]
+
+}
+
+
+(* special character classes *)
+let space = [' ' '\t' '\r']+
+let newline = "\n" | "\r" | "\r\n"
+
+(* utilities *)
+let digit = ['0'-'9']
+let digit_ = ['0'-'9' '_']
+
+(* integers *)
+let int_dec = digit digit_*
+let int_bin = ("0b" | "0B") ['0'-'1'] ['0'-'1' '_']*
+let int_oct = ("0o" | "0O") ['0'-'7'] ['0'-'7' '_']*
+let int_hex = ("0x" | "0X") ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F' '_']*
+let const_int = int_bin | int_oct | int_dec | int_hex
+
+(* tokens *)
+rule token = parse
+
+(* identifier (TOK_id) or reserved keyword *)
+| ['a'-'z' 'A'-'Z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']* as id
+{ try Hashtbl.find kwd_table id with Not_found -> IDENT id }
+
+(* symbols *)
+| "("    { LPAREN }
+| ")"    { RPAREN }
+| "{"    { LCURLY }
+| "}"    { RCURLY }
+| "*"    { STAR }
+| "+"    { PLUS }
+| "-"    { MINUS }
+| "!"    { EXCLAIM }
+| "/"    { DIVIDE }
+| "%"    { PERCENT }
+| "<"    { LESS }
+| ">"    { GREATER }
+| "<="   { LESS_EQUAL }
+| ">="   { GREATER_EQUAL }
+| "=="   { EQUAL_EQUAL }
+| "<>"   { DIFF }
+| "&&"   { AND_AND }
+| "||"   { BAR_BAR }
+| ";"    { SEMICOLON }
+| ":"    { COLON }
+| ","    { COMMA }
+| "="    { EQUAL }
+| "->"   { ARROW }
+
+(* literals *)
+| const_int    as c { INTVAL c }
+
+(* spaces, comments *)
+| "(*" { comment lexbuf; token lexbuf }
+| "--" [^ '\n' '\r']* { token lexbuf }
+| newline { new_line lexbuf; token lexbuf }
+| space { token lexbuf }
+
+(* end of files *)
+| eof { EOF }
+
+
+(* nested comments (handled recursively)  *)
+and comment = parse
+| "*)" { () }
+| [^ '\n' '\r'] { comment lexbuf }
+| newline { new_line lexbuf; comment lexbuf }
diff --git a/frontend/parser.automaton b/frontend/parser.automaton
new file mode 100644
index 0000000..dff892b
--- /dev/null
+++ b/frontend/parser.automaton
@@ -0,0 +1,1577 @@
+State 0:
+file' -> . file [ # ]
+-- On NODE shift to state 1
+-- On CONST shift to state 103
+-- On toplevel shift to state 109
+-- On node_decl shift to state 110
+-- On list(toplevel) shift to state 113
+-- On file shift to state 115
+-- On const_decl shift to state 112
+-- On EOF reduce production list(toplevel) -> 
+
+State 1:
+node_decl -> NODE . IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On IDENT shift to state 2
+
+State 2:
+node_decl -> NODE IDENT . LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On LPAREN shift to state 3
+
+State 3:
+node_decl -> NODE IDENT LPAREN . vars RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On IDENT shift to state 4
+-- On vars shift to state 10
+-- On var shift to state 98
+-- On separated_nonempty_list(SEMICOLON,var) shift to state 101
+-- On loption(separated_nonempty_list(SEMICOLON,var)) shift to state 102
+-- On RPAREN reduce production loption(separated_nonempty_list(SEMICOLON,var)) -> 
+
+State 4:
+var -> IDENT . COLON typ [ SEMICOLON RPAREN ]
+-- On COLON shift to state 5
+
+State 5:
+var -> IDENT COLON . typ [ SEMICOLON RPAREN ]
+-- On REAL shift to state 6
+-- On INT shift to state 7
+-- On BOOL shift to state 8
+-- On typ shift to state 9
+
+State 6:
+typ -> REAL . [ SEMICOLON RPAREN EQUAL ]
+-- On SEMICOLON reduce production typ -> REAL 
+-- On RPAREN reduce production typ -> REAL 
+-- On EQUAL reduce production typ -> REAL 
+
+State 7:
+typ -> INT . [ SEMICOLON RPAREN EQUAL ]
+-- On SEMICOLON reduce production typ -> INT 
+-- On RPAREN reduce production typ -> INT 
+-- On EQUAL reduce production typ -> INT 
+
+State 8:
+typ -> BOOL . [ SEMICOLON RPAREN EQUAL ]
+-- On SEMICOLON reduce production typ -> BOOL 
+-- On RPAREN reduce production typ -> BOOL 
+-- On EQUAL reduce production typ -> BOOL 
+
+State 9:
+var -> IDENT COLON typ . [ SEMICOLON RPAREN ]
+-- On SEMICOLON reduce production var -> IDENT COLON typ 
+-- On RPAREN reduce production var -> IDENT COLON typ 
+
+State 10:
+node_decl -> NODE IDENT LPAREN vars . RPAREN RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On RPAREN shift to state 11
+
+State 11:
+node_decl -> NODE IDENT LPAREN vars RPAREN . RETURNS vars RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On RETURNS shift to state 12
+
+State 12:
+node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS . vars RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On IDENT shift to state 4
+-- On vars shift to state 13
+-- On var shift to state 98
+-- On separated_nonempty_list(SEMICOLON,var) shift to state 101
+-- On loption(separated_nonempty_list(SEMICOLON,var)) shift to state 102
+-- On RPAREN reduce production loption(separated_nonempty_list(SEMICOLON,var)) -> 
+
+State 13:
+node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars . RPAREN var_decl dbody [ NODE EOF CONST ]
+-- On RPAREN shift to state 14
+
+State 14:
+node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN . var_decl dbody [ NODE EOF CONST ]
+-- On VAR shift to state 15
+-- On var_decl shift to state 20
+-- On LET reduce production var_decl -> 
+-- On IDENT reduce production var_decl -> 
+-- On GUARANTEE reduce production var_decl -> 
+-- On ASSUME reduce production var_decl -> 
+
+State 15:
+var_decl -> VAR . nonempty_list(terminated(var,SEMICOLON)) [ LET IDENT GUARANTEE ASSUME ]
+-- On IDENT shift to state 4
+-- On var shift to state 16
+-- On nonempty_list(terminated(var,SEMICOLON)) shift to state 19
+
+State 16:
+nonempty_list(terminated(var,SEMICOLON)) -> var . SEMICOLON [ LET IDENT GUARANTEE ASSUME ]
+nonempty_list(terminated(var,SEMICOLON)) -> var . SEMICOLON nonempty_list(terminated(var,SEMICOLON)) [ LET IDENT GUARANTEE ASSUME ]
+-- On SEMICOLON shift to state 17
+
+State 17:
+nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON . [ LET IDENT GUARANTEE ASSUME ]
+nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON . nonempty_list(terminated(var,SEMICOLON)) [ LET IDENT GUARANTEE ASSUME ]
+-- On IDENT shift to state 4
+-- On var shift to state 16
+-- On nonempty_list(terminated(var,SEMICOLON)) shift to state 18
+-- On LET reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON 
+-- On IDENT reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON 
+-- On GUARANTEE reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON 
+-- On ASSUME reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON 
+** Conflict on IDENT
+
+State 18:
+nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) . [ LET IDENT GUARANTEE ASSUME ]
+-- On LET reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) 
+-- On IDENT reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) 
+-- On GUARANTEE reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) 
+-- On ASSUME reduce production nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) 
+
+State 19:
+var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) . [ LET IDENT GUARANTEE ASSUME ]
+-- On LET reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) 
+-- On IDENT reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) 
+-- On GUARANTEE reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) 
+-- On ASSUME reduce production var_decl -> VAR nonempty_list(terminated(var,SEMICOLON)) 
+
+State 20:
+node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl . dbody [ NODE EOF CONST ]
+-- On LET shift to state 21
+-- On IDENT shift to state 22
+-- On GUARANTEE shift to state 23
+-- On ASSUME shift to state 83
+-- On lvalue shift to state 89
+-- On eqn shift to state 95
+-- On dbody shift to state 97
+
+State 21:
+dbody -> LET . separated_nonempty_list(SEMICOLON,ext(eqn)) TEL [ NODE EOF CONST ]
+-- On IDENT shift to state 22
+-- On GUARANTEE shift to state 23
+-- On ASSUME shift to state 83
+-- On separated_nonempty_list(SEMICOLON,ext(eqn)) shift to state 87
+-- On lvalue shift to state 89
+-- On eqn shift to state 92
+
+State 22:
+lvalue -> IDENT . [ EQUAL ]
+-- On EQUAL reduce production lvalue -> IDENT 
+
+State 23:
+eqn -> GUARANTEE . IDENT COLON expr [ TEL SEMICOLON ]
+-- On IDENT shift to state 24
+
+State 24:
+eqn -> GUARANTEE IDENT . COLON expr [ TEL SEMICOLON ]
+-- On COLON shift to state 25
+
+State 25:
+eqn -> GUARANTEE IDENT COLON . expr [ TEL SEMICOLON ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 82
+-- On binary_expr shift to state 45
+
+State 26:
+primary_expr -> TRUE . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production primary_expr -> TRUE 
+-- On TEL reduce production primary_expr -> TRUE 
+-- On STAR reduce production primary_expr -> TRUE 
+-- On SEMICOLON reduce production primary_expr -> TRUE 
+-- On RPAREN reduce production primary_expr -> TRUE 
+-- On PLUS reduce production primary_expr -> TRUE 
+-- On PERCENT reduce production primary_expr -> TRUE 
+-- On NOT_EQUAL reduce production primary_expr -> TRUE 
+-- On NODE reduce production primary_expr -> TRUE 
+-- On MINUS reduce production primary_expr -> TRUE 
+-- On LESS_EQUAL reduce production primary_expr -> TRUE 
+-- On LESS reduce production primary_expr -> TRUE 
+-- On GREATER_EQUAL reduce production primary_expr -> TRUE 
+-- On GREATER reduce production primary_expr -> TRUE 
+-- On EQUAL_EQUAL reduce production primary_expr -> TRUE 
+-- On EOF reduce production primary_expr -> TRUE 
+-- On ELSE reduce production primary_expr -> TRUE 
+-- On DIVIDE reduce production primary_expr -> TRUE 
+-- On CONST reduce production primary_expr -> TRUE 
+-- On COMMA reduce production primary_expr -> TRUE 
+-- On BAR_BAR reduce production primary_expr -> TRUE 
+-- On AND_AND reduce production primary_expr -> TRUE 
+
+State 27:
+unary_expr -> PLUS . unary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 81
+-- On primary_expr shift to state 38
+
+State 28:
+unary_expr -> NOT . unary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 80
+-- On primary_expr shift to state 38
+
+State 29:
+unary_expr -> MINUS . unary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 79
+-- On primary_expr shift to state 38
+
+State 30:
+primary_expr -> LPAREN . expr RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 77
+-- On binary_expr shift to state 45
+
+State 31:
+primary_expr -> INTVAL . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production primary_expr -> INTVAL 
+-- On TEL reduce production primary_expr -> INTVAL 
+-- On STAR reduce production primary_expr -> INTVAL 
+-- On SEMICOLON reduce production primary_expr -> INTVAL 
+-- On RPAREN reduce production primary_expr -> INTVAL 
+-- On PLUS reduce production primary_expr -> INTVAL 
+-- On PERCENT reduce production primary_expr -> INTVAL 
+-- On NOT_EQUAL reduce production primary_expr -> INTVAL 
+-- On NODE reduce production primary_expr -> INTVAL 
+-- On MINUS reduce production primary_expr -> INTVAL 
+-- On LESS_EQUAL reduce production primary_expr -> INTVAL 
+-- On LESS reduce production primary_expr -> INTVAL 
+-- On GREATER_EQUAL reduce production primary_expr -> INTVAL 
+-- On GREATER reduce production primary_expr -> INTVAL 
+-- On EQUAL_EQUAL reduce production primary_expr -> INTVAL 
+-- On EOF reduce production primary_expr -> INTVAL 
+-- On ELSE reduce production primary_expr -> INTVAL 
+-- On DIVIDE reduce production primary_expr -> INTVAL 
+-- On CONST reduce production primary_expr -> INTVAL 
+-- On COMMA reduce production primary_expr -> INTVAL 
+-- On BAR_BAR reduce production primary_expr -> INTVAL 
+-- On AND_AND reduce production primary_expr -> INTVAL 
+
+State 32:
+if_expr -> IF . expr THEN expr ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 72
+-- On binary_expr shift to state 45
+
+State 33:
+primary_expr -> IDENT . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+primary_expr -> IDENT . LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On LPAREN shift to state 34
+-- On THEN reduce production primary_expr -> IDENT 
+-- On TEL reduce production primary_expr -> IDENT 
+-- On STAR reduce production primary_expr -> IDENT 
+-- On SEMICOLON reduce production primary_expr -> IDENT 
+-- On RPAREN reduce production primary_expr -> IDENT 
+-- On PLUS reduce production primary_expr -> IDENT 
+-- On PERCENT reduce production primary_expr -> IDENT 
+-- On NOT_EQUAL reduce production primary_expr -> IDENT 
+-- On NODE reduce production primary_expr -> IDENT 
+-- On MINUS reduce production primary_expr -> IDENT 
+-- On LESS_EQUAL reduce production primary_expr -> IDENT 
+-- On LESS reduce production primary_expr -> IDENT 
+-- On GREATER_EQUAL reduce production primary_expr -> IDENT 
+-- On GREATER reduce production primary_expr -> IDENT 
+-- On EQUAL_EQUAL reduce production primary_expr -> IDENT 
+-- On EOF reduce production primary_expr -> IDENT 
+-- On ELSE reduce production primary_expr -> IDENT 
+-- On DIVIDE reduce production primary_expr -> IDENT 
+-- On CONST reduce production primary_expr -> IDENT 
+-- On COMMA reduce production primary_expr -> IDENT 
+-- On BAR_BAR reduce production primary_expr -> IDENT 
+-- On AND_AND reduce production primary_expr -> IDENT 
+
+State 34:
+primary_expr -> IDENT LPAREN . loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On separated_nonempty_list(COMMA,ext(expr)) shift to state 37
+-- On primary_expr shift to state 38
+-- On loption(separated_nonempty_list(COMMA,ext(expr))) shift to state 39
+-- On if_expr shift to state 41
+-- On expr shift to state 42
+-- On binary_expr shift to state 45
+-- On RPAREN reduce production loption(separated_nonempty_list(COMMA,ext(expr))) -> 
+
+State 35:
+primary_expr -> FALSE . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production primary_expr -> FALSE 
+-- On TEL reduce production primary_expr -> FALSE 
+-- On STAR reduce production primary_expr -> FALSE 
+-- On SEMICOLON reduce production primary_expr -> FALSE 
+-- On RPAREN reduce production primary_expr -> FALSE 
+-- On PLUS reduce production primary_expr -> FALSE 
+-- On PERCENT reduce production primary_expr -> FALSE 
+-- On NOT_EQUAL reduce production primary_expr -> FALSE 
+-- On NODE reduce production primary_expr -> FALSE 
+-- On MINUS reduce production primary_expr -> FALSE 
+-- On LESS_EQUAL reduce production primary_expr -> FALSE 
+-- On LESS reduce production primary_expr -> FALSE 
+-- On GREATER_EQUAL reduce production primary_expr -> FALSE 
+-- On GREATER reduce production primary_expr -> FALSE 
+-- On EQUAL_EQUAL reduce production primary_expr -> FALSE 
+-- On EOF reduce production primary_expr -> FALSE 
+-- On ELSE reduce production primary_expr -> FALSE 
+-- On DIVIDE reduce production primary_expr -> FALSE 
+-- On CONST reduce production primary_expr -> FALSE 
+-- On COMMA reduce production primary_expr -> FALSE 
+-- On BAR_BAR reduce production primary_expr -> FALSE 
+-- On AND_AND reduce production primary_expr -> FALSE 
+
+State 36:
+binary_expr -> unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production binary_expr -> unary_expr 
+-- On TEL reduce production binary_expr -> unary_expr 
+-- On STAR reduce production binary_expr -> unary_expr 
+-- On SEMICOLON reduce production binary_expr -> unary_expr 
+-- On RPAREN reduce production binary_expr -> unary_expr 
+-- On PLUS reduce production binary_expr -> unary_expr 
+-- On PERCENT reduce production binary_expr -> unary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> unary_expr 
+-- On NODE reduce production binary_expr -> unary_expr 
+-- On MINUS reduce production binary_expr -> unary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> unary_expr 
+-- On LESS reduce production binary_expr -> unary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> unary_expr 
+-- On GREATER reduce production binary_expr -> unary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> unary_expr 
+-- On EOF reduce production binary_expr -> unary_expr 
+-- On ELSE reduce production binary_expr -> unary_expr 
+-- On DIVIDE reduce production binary_expr -> unary_expr 
+-- On CONST reduce production binary_expr -> unary_expr 
+-- On COMMA reduce production binary_expr -> unary_expr 
+-- On BAR_BAR reduce production binary_expr -> unary_expr 
+-- On AND_AND reduce production binary_expr -> unary_expr 
+
+State 37:
+loption(separated_nonempty_list(COMMA,ext(expr))) -> separated_nonempty_list(COMMA,ext(expr)) . [ RPAREN ]
+-- On RPAREN reduce production loption(separated_nonempty_list(COMMA,ext(expr))) -> separated_nonempty_list(COMMA,ext(expr)) 
+
+State 38:
+unary_expr -> primary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production unary_expr -> primary_expr 
+-- On TEL reduce production unary_expr -> primary_expr 
+-- On STAR reduce production unary_expr -> primary_expr 
+-- On SEMICOLON reduce production unary_expr -> primary_expr 
+-- On RPAREN reduce production unary_expr -> primary_expr 
+-- On PLUS reduce production unary_expr -> primary_expr 
+-- On PERCENT reduce production unary_expr -> primary_expr 
+-- On NOT_EQUAL reduce production unary_expr -> primary_expr 
+-- On NODE reduce production unary_expr -> primary_expr 
+-- On MINUS reduce production unary_expr -> primary_expr 
+-- On LESS_EQUAL reduce production unary_expr -> primary_expr 
+-- On LESS reduce production unary_expr -> primary_expr 
+-- On GREATER_EQUAL reduce production unary_expr -> primary_expr 
+-- On GREATER reduce production unary_expr -> primary_expr 
+-- On EQUAL_EQUAL reduce production unary_expr -> primary_expr 
+-- On EOF reduce production unary_expr -> primary_expr 
+-- On ELSE reduce production unary_expr -> primary_expr 
+-- On DIVIDE reduce production unary_expr -> primary_expr 
+-- On CONST reduce production unary_expr -> primary_expr 
+-- On COMMA reduce production unary_expr -> primary_expr 
+-- On BAR_BAR reduce production unary_expr -> primary_expr 
+-- On AND_AND reduce production unary_expr -> primary_expr 
+
+State 39:
+primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) . RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On RPAREN shift to state 40
+
+State 40:
+primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On TEL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On STAR reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On SEMICOLON reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On RPAREN reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On PLUS reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On PERCENT reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On NOT_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On NODE reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On MINUS reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On LESS_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On LESS reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On GREATER_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On GREATER reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On EQUAL_EQUAL reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On EOF reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On ELSE reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On DIVIDE reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On CONST reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On COMMA reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On BAR_BAR reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+-- On AND_AND reduce production primary_expr -> IDENT LPAREN loption(separated_nonempty_list(COMMA,ext(expr))) RPAREN 
+
+State 41:
+expr -> if_expr . [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On THEN reduce production expr -> if_expr 
+-- On TEL reduce production expr -> if_expr 
+-- On SEMICOLON reduce production expr -> if_expr 
+-- On RPAREN reduce production expr -> if_expr 
+-- On NODE reduce production expr -> if_expr 
+-- On EOF reduce production expr -> if_expr 
+-- On ELSE reduce production expr -> if_expr 
+-- On CONST reduce production expr -> if_expr 
+-- On COMMA reduce production expr -> if_expr 
+
+State 42:
+separated_nonempty_list(COMMA,ext(expr)) -> expr . [ RPAREN ]
+separated_nonempty_list(COMMA,ext(expr)) -> expr . COMMA separated_nonempty_list(COMMA,ext(expr)) [ RPAREN ]
+-- On COMMA shift to state 43
+-- On RPAREN reduce production separated_nonempty_list(COMMA,ext(expr)) -> expr 
+
+State 43:
+separated_nonempty_list(COMMA,ext(expr)) -> expr COMMA . separated_nonempty_list(COMMA,ext(expr)) [ RPAREN ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On separated_nonempty_list(COMMA,ext(expr)) shift to state 44
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 42
+-- On binary_expr shift to state 45
+
+State 44:
+separated_nonempty_list(COMMA,ext(expr)) -> expr COMMA separated_nonempty_list(COMMA,ext(expr)) . [ RPAREN ]
+-- On RPAREN reduce production separated_nonempty_list(COMMA,ext(expr)) -> expr COMMA separated_nonempty_list(COMMA,ext(expr)) 
+
+State 45:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+if_expr -> binary_expr . [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On NOT_EQUAL shift to state 54
+-- On MINUS shift to state 56
+-- On LESS_EQUAL shift to state 58
+-- On LESS shift to state 60
+-- On GREATER_EQUAL shift to state 62
+-- On GREATER shift to state 64
+-- On EQUAL_EQUAL shift to state 66
+-- On DIVIDE shift to state 52
+-- On BAR_BAR shift to state 68
+-- On AND_AND shift to state 70
+-- On THEN reduce production if_expr -> binary_expr 
+-- On TEL reduce production if_expr -> binary_expr 
+-- On SEMICOLON reduce production if_expr -> binary_expr 
+-- On RPAREN reduce production if_expr -> binary_expr 
+-- On NODE reduce production if_expr -> binary_expr 
+-- On EOF reduce production if_expr -> binary_expr 
+-- On ELSE reduce production if_expr -> binary_expr 
+-- On CONST reduce production if_expr -> binary_expr 
+-- On COMMA reduce production if_expr -> binary_expr 
+
+State 46:
+binary_expr -> binary_expr STAR . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 47
+
+State 47:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr STAR binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On STAR reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On PLUS reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On PERCENT reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On MINUS reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On DIVIDE reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr STAR binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr STAR binary_expr 
+
+State 48:
+binary_expr -> binary_expr PLUS . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 49
+
+State 49:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr PLUS binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PERCENT shift to state 50
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On PLUS reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On MINUS reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr PLUS binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr PLUS binary_expr 
+
+State 50:
+binary_expr -> binary_expr PERCENT . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 51
+
+State 51:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr PERCENT binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On STAR reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On PLUS reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On PERCENT reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On MINUS reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On DIVIDE reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr PERCENT binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr PERCENT binary_expr 
+
+State 52:
+binary_expr -> binary_expr DIVIDE . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 53
+
+State 53:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr DIVIDE binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On STAR reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On PLUS reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On PERCENT reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On MINUS reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On DIVIDE reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr DIVIDE binary_expr 
+
+State 54:
+binary_expr -> binary_expr NOT_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 55
+
+State 55:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr NOT_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On MINUS shift to state 56
+-- On LESS_EQUAL shift to state 58
+-- On LESS shift to state 60
+-- On GREATER_EQUAL shift to state 62
+-- On GREATER shift to state 64
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr NOT_EQUAL binary_expr 
+
+State 56:
+binary_expr -> binary_expr MINUS . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 57
+
+State 57:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr MINUS binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PERCENT shift to state 50
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On PLUS reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On MINUS reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr MINUS binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr MINUS binary_expr 
+
+State 58:
+binary_expr -> binary_expr LESS_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 59
+
+State 59:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr LESS_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On MINUS shift to state 56
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr LESS_EQUAL binary_expr 
+
+State 60:
+binary_expr -> binary_expr LESS . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 61
+
+State 61:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr LESS binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On MINUS shift to state 56
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr LESS binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr LESS binary_expr 
+
+State 62:
+binary_expr -> binary_expr GREATER_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 63
+
+State 63:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr GREATER_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On MINUS shift to state 56
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr GREATER_EQUAL binary_expr 
+
+State 64:
+binary_expr -> binary_expr GREATER . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 65
+
+State 65:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr GREATER binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On MINUS shift to state 56
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On LESS_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On LESS reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On GREATER_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On GREATER reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr GREATER binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr GREATER binary_expr 
+
+State 66:
+binary_expr -> binary_expr EQUAL_EQUAL . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 67
+
+State 67:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr EQUAL_EQUAL binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On MINUS shift to state 56
+-- On LESS_EQUAL shift to state 58
+-- On LESS shift to state 60
+-- On GREATER_EQUAL shift to state 62
+-- On GREATER shift to state 64
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On NOT_EQUAL reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On EQUAL_EQUAL reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr EQUAL_EQUAL binary_expr 
+
+State 68:
+binary_expr -> binary_expr BAR_BAR . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 69
+
+State 69:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr BAR_BAR binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On NOT_EQUAL shift to state 54
+-- On MINUS shift to state 56
+-- On LESS_EQUAL shift to state 58
+-- On LESS shift to state 60
+-- On GREATER_EQUAL shift to state 62
+-- On GREATER shift to state 64
+-- On EQUAL_EQUAL shift to state 66
+-- On DIVIDE shift to state 52
+-- On AND_AND shift to state 70
+-- On THEN reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr BAR_BAR binary_expr 
+
+State 70:
+binary_expr -> binary_expr AND_AND . binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On binary_expr shift to state 71
+
+State 71:
+binary_expr -> binary_expr . STAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . DIVIDE binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PERCENT binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . PLUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . MINUS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . LESS_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . GREATER_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . EQUAL_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . NOT_EQUAL binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . AND_AND binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr AND_AND binary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+binary_expr -> binary_expr . BAR_BAR binary_expr [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On STAR shift to state 46
+-- On PLUS shift to state 48
+-- On PERCENT shift to state 50
+-- On NOT_EQUAL shift to state 54
+-- On MINUS shift to state 56
+-- On LESS_EQUAL shift to state 58
+-- On LESS shift to state 60
+-- On GREATER_EQUAL shift to state 62
+-- On GREATER shift to state 64
+-- On EQUAL_EQUAL shift to state 66
+-- On DIVIDE shift to state 52
+-- On THEN reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On TEL reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On SEMICOLON reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On RPAREN reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On NODE reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On EOF reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On ELSE reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On CONST reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On COMMA reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On BAR_BAR reduce production binary_expr -> binary_expr AND_AND binary_expr 
+-- On AND_AND reduce production binary_expr -> binary_expr AND_AND binary_expr 
+
+State 72:
+if_expr -> IF expr . THEN expr ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On THEN shift to state 73
+
+State 73:
+if_expr -> IF expr THEN . expr ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 74
+-- On binary_expr shift to state 45
+
+State 74:
+if_expr -> IF expr THEN expr . ELSE expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On ELSE shift to state 75
+
+State 75:
+if_expr -> IF expr THEN expr ELSE . expr [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 76
+-- On binary_expr shift to state 45
+
+State 76:
+if_expr -> IF expr THEN expr ELSE expr . [ THEN TEL SEMICOLON RPAREN NODE EOF ELSE CONST COMMA ]
+-- On THEN reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On TEL reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On SEMICOLON reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On RPAREN reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On NODE reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On EOF reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On ELSE reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On CONST reduce production if_expr -> IF expr THEN expr ELSE expr 
+-- On COMMA reduce production if_expr -> IF expr THEN expr ELSE expr 
+
+State 77:
+primary_expr -> LPAREN expr . RPAREN [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On RPAREN shift to state 78
+
+State 78:
+primary_expr -> LPAREN expr RPAREN . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production primary_expr -> LPAREN expr RPAREN 
+-- On TEL reduce production primary_expr -> LPAREN expr RPAREN 
+-- On STAR reduce production primary_expr -> LPAREN expr RPAREN 
+-- On SEMICOLON reduce production primary_expr -> LPAREN expr RPAREN 
+-- On RPAREN reduce production primary_expr -> LPAREN expr RPAREN 
+-- On PLUS reduce production primary_expr -> LPAREN expr RPAREN 
+-- On PERCENT reduce production primary_expr -> LPAREN expr RPAREN 
+-- On NOT_EQUAL reduce production primary_expr -> LPAREN expr RPAREN 
+-- On NODE reduce production primary_expr -> LPAREN expr RPAREN 
+-- On MINUS reduce production primary_expr -> LPAREN expr RPAREN 
+-- On LESS_EQUAL reduce production primary_expr -> LPAREN expr RPAREN 
+-- On LESS reduce production primary_expr -> LPAREN expr RPAREN 
+-- On GREATER_EQUAL reduce production primary_expr -> LPAREN expr RPAREN 
+-- On GREATER reduce production primary_expr -> LPAREN expr RPAREN 
+-- On EQUAL_EQUAL reduce production primary_expr -> LPAREN expr RPAREN 
+-- On EOF reduce production primary_expr -> LPAREN expr RPAREN 
+-- On ELSE reduce production primary_expr -> LPAREN expr RPAREN 
+-- On DIVIDE reduce production primary_expr -> LPAREN expr RPAREN 
+-- On CONST reduce production primary_expr -> LPAREN expr RPAREN 
+-- On COMMA reduce production primary_expr -> LPAREN expr RPAREN 
+-- On BAR_BAR reduce production primary_expr -> LPAREN expr RPAREN 
+-- On AND_AND reduce production primary_expr -> LPAREN expr RPAREN 
+
+State 79:
+unary_expr -> MINUS unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production unary_expr -> MINUS unary_expr 
+-- On TEL reduce production unary_expr -> MINUS unary_expr 
+-- On STAR reduce production unary_expr -> MINUS unary_expr 
+-- On SEMICOLON reduce production unary_expr -> MINUS unary_expr 
+-- On RPAREN reduce production unary_expr -> MINUS unary_expr 
+-- On PLUS reduce production unary_expr -> MINUS unary_expr 
+-- On PERCENT reduce production unary_expr -> MINUS unary_expr 
+-- On NOT_EQUAL reduce production unary_expr -> MINUS unary_expr 
+-- On NODE reduce production unary_expr -> MINUS unary_expr 
+-- On MINUS reduce production unary_expr -> MINUS unary_expr 
+-- On LESS_EQUAL reduce production unary_expr -> MINUS unary_expr 
+-- On LESS reduce production unary_expr -> MINUS unary_expr 
+-- On GREATER_EQUAL reduce production unary_expr -> MINUS unary_expr 
+-- On GREATER reduce production unary_expr -> MINUS unary_expr 
+-- On EQUAL_EQUAL reduce production unary_expr -> MINUS unary_expr 
+-- On EOF reduce production unary_expr -> MINUS unary_expr 
+-- On ELSE reduce production unary_expr -> MINUS unary_expr 
+-- On DIVIDE reduce production unary_expr -> MINUS unary_expr 
+-- On CONST reduce production unary_expr -> MINUS unary_expr 
+-- On COMMA reduce production unary_expr -> MINUS unary_expr 
+-- On BAR_BAR reduce production unary_expr -> MINUS unary_expr 
+-- On AND_AND reduce production unary_expr -> MINUS unary_expr 
+
+State 80:
+unary_expr -> NOT unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production unary_expr -> NOT unary_expr 
+-- On TEL reduce production unary_expr -> NOT unary_expr 
+-- On STAR reduce production unary_expr -> NOT unary_expr 
+-- On SEMICOLON reduce production unary_expr -> NOT unary_expr 
+-- On RPAREN reduce production unary_expr -> NOT unary_expr 
+-- On PLUS reduce production unary_expr -> NOT unary_expr 
+-- On PERCENT reduce production unary_expr -> NOT unary_expr 
+-- On NOT_EQUAL reduce production unary_expr -> NOT unary_expr 
+-- On NODE reduce production unary_expr -> NOT unary_expr 
+-- On MINUS reduce production unary_expr -> NOT unary_expr 
+-- On LESS_EQUAL reduce production unary_expr -> NOT unary_expr 
+-- On LESS reduce production unary_expr -> NOT unary_expr 
+-- On GREATER_EQUAL reduce production unary_expr -> NOT unary_expr 
+-- On GREATER reduce production unary_expr -> NOT unary_expr 
+-- On EQUAL_EQUAL reduce production unary_expr -> NOT unary_expr 
+-- On EOF reduce production unary_expr -> NOT unary_expr 
+-- On ELSE reduce production unary_expr -> NOT unary_expr 
+-- On DIVIDE reduce production unary_expr -> NOT unary_expr 
+-- On CONST reduce production unary_expr -> NOT unary_expr 
+-- On COMMA reduce production unary_expr -> NOT unary_expr 
+-- On BAR_BAR reduce production unary_expr -> NOT unary_expr 
+-- On AND_AND reduce production unary_expr -> NOT unary_expr 
+
+State 81:
+unary_expr -> PLUS unary_expr . [ THEN TEL STAR SEMICOLON RPAREN PLUS PERCENT NOT_EQUAL NODE MINUS LESS_EQUAL LESS GREATER_EQUAL GREATER EQUAL_EQUAL EOF ELSE DIVIDE CONST COMMA BAR_BAR AND_AND ]
+-- On THEN reduce production unary_expr -> PLUS unary_expr 
+-- On TEL reduce production unary_expr -> PLUS unary_expr 
+-- On STAR reduce production unary_expr -> PLUS unary_expr 
+-- On SEMICOLON reduce production unary_expr -> PLUS unary_expr 
+-- On RPAREN reduce production unary_expr -> PLUS unary_expr 
+-- On PLUS reduce production unary_expr -> PLUS unary_expr 
+-- On PERCENT reduce production unary_expr -> PLUS unary_expr 
+-- On NOT_EQUAL reduce production unary_expr -> PLUS unary_expr 
+-- On NODE reduce production unary_expr -> PLUS unary_expr 
+-- On MINUS reduce production unary_expr -> PLUS unary_expr 
+-- On LESS_EQUAL reduce production unary_expr -> PLUS unary_expr 
+-- On LESS reduce production unary_expr -> PLUS unary_expr 
+-- On GREATER_EQUAL reduce production unary_expr -> PLUS unary_expr 
+-- On GREATER reduce production unary_expr -> PLUS unary_expr 
+-- On EQUAL_EQUAL reduce production unary_expr -> PLUS unary_expr 
+-- On EOF reduce production unary_expr -> PLUS unary_expr 
+-- On ELSE reduce production unary_expr -> PLUS unary_expr 
+-- On DIVIDE reduce production unary_expr -> PLUS unary_expr 
+-- On CONST reduce production unary_expr -> PLUS unary_expr 
+-- On COMMA reduce production unary_expr -> PLUS unary_expr 
+-- On BAR_BAR reduce production unary_expr -> PLUS unary_expr 
+-- On AND_AND reduce production unary_expr -> PLUS unary_expr 
+
+State 82:
+eqn -> GUARANTEE IDENT COLON expr . [ TEL SEMICOLON ]
+-- On TEL reduce production eqn -> GUARANTEE IDENT COLON expr 
+-- On SEMICOLON reduce production eqn -> GUARANTEE IDENT COLON expr 
+
+State 83:
+eqn -> ASSUME . IDENT COLON expr [ TEL SEMICOLON ]
+-- On IDENT shift to state 84
+
+State 84:
+eqn -> ASSUME IDENT . COLON expr [ TEL SEMICOLON ]
+-- On COLON shift to state 85
+
+State 85:
+eqn -> ASSUME IDENT COLON . expr [ TEL SEMICOLON ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 86
+-- On binary_expr shift to state 45
+
+State 86:
+eqn -> ASSUME IDENT COLON expr . [ TEL SEMICOLON ]
+-- On TEL reduce production eqn -> ASSUME IDENT COLON expr 
+-- On SEMICOLON reduce production eqn -> ASSUME IDENT COLON expr 
+
+State 87:
+dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) . TEL [ NODE EOF CONST ]
+-- On TEL shift to state 88
+
+State 88:
+dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL . [ NODE EOF CONST ]
+-- On NODE reduce production dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL 
+-- On EOF reduce production dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL 
+-- On CONST reduce production dbody -> LET separated_nonempty_list(SEMICOLON,ext(eqn)) TEL 
+
+State 89:
+eqn -> lvalue . EQUAL expr [ TEL SEMICOLON ]
+-- On EQUAL shift to state 90
+
+State 90:
+eqn -> lvalue EQUAL . expr [ TEL SEMICOLON ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 91
+-- On binary_expr shift to state 45
+
+State 91:
+eqn -> lvalue EQUAL expr . [ TEL SEMICOLON ]
+-- On TEL reduce production eqn -> lvalue EQUAL expr 
+-- On SEMICOLON reduce production eqn -> lvalue EQUAL expr 
+
+State 92:
+separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn . [ TEL ]
+separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn . SEMICOLON separated_nonempty_list(SEMICOLON,ext(eqn)) [ TEL ]
+-- On SEMICOLON shift to state 93
+-- On TEL reduce production separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn 
+
+State 93:
+separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn SEMICOLON . separated_nonempty_list(SEMICOLON,ext(eqn)) [ TEL ]
+-- On IDENT shift to state 22
+-- On GUARANTEE shift to state 23
+-- On ASSUME shift to state 83
+-- On separated_nonempty_list(SEMICOLON,ext(eqn)) shift to state 94
+-- On lvalue shift to state 89
+-- On eqn shift to state 92
+
+State 94:
+separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn SEMICOLON separated_nonempty_list(SEMICOLON,ext(eqn)) . [ TEL ]
+-- On TEL reduce production separated_nonempty_list(SEMICOLON,ext(eqn)) -> eqn SEMICOLON separated_nonempty_list(SEMICOLON,ext(eqn)) 
+
+State 95:
+dbody -> eqn . SEMICOLON [ NODE EOF CONST ]
+-- On SEMICOLON shift to state 96
+
+State 96:
+dbody -> eqn SEMICOLON . [ NODE EOF CONST ]
+-- On NODE reduce production dbody -> eqn SEMICOLON 
+-- On EOF reduce production dbody -> eqn SEMICOLON 
+-- On CONST reduce production dbody -> eqn SEMICOLON 
+
+State 97:
+node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody . [ NODE EOF CONST ]
+-- On NODE reduce production node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody 
+-- On EOF reduce production node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody 
+-- On CONST reduce production node_decl -> NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody 
+
+State 98:
+separated_nonempty_list(SEMICOLON,var) -> var . [ RPAREN ]
+separated_nonempty_list(SEMICOLON,var) -> var . SEMICOLON separated_nonempty_list(SEMICOLON,var) [ RPAREN ]
+-- On SEMICOLON shift to state 99
+-- On RPAREN reduce production separated_nonempty_list(SEMICOLON,var) -> var 
+
+State 99:
+separated_nonempty_list(SEMICOLON,var) -> var SEMICOLON . separated_nonempty_list(SEMICOLON,var) [ RPAREN ]
+-- On IDENT shift to state 4
+-- On var shift to state 98
+-- On separated_nonempty_list(SEMICOLON,var) shift to state 100
+
+State 100:
+separated_nonempty_list(SEMICOLON,var) -> var SEMICOLON separated_nonempty_list(SEMICOLON,var) . [ RPAREN ]
+-- On RPAREN reduce production separated_nonempty_list(SEMICOLON,var) -> var SEMICOLON separated_nonempty_list(SEMICOLON,var) 
+
+State 101:
+loption(separated_nonempty_list(SEMICOLON,var)) -> separated_nonempty_list(SEMICOLON,var) . [ RPAREN ]
+-- On RPAREN reduce production loption(separated_nonempty_list(SEMICOLON,var)) -> separated_nonempty_list(SEMICOLON,var) 
+
+State 102:
+vars -> loption(separated_nonempty_list(SEMICOLON,var)) . [ RPAREN ]
+-- On RPAREN reduce production vars -> loption(separated_nonempty_list(SEMICOLON,var)) 
+
+State 103:
+const_decl -> CONST . IDENT COLON typ EQUAL expr [ NODE EOF CONST ]
+-- On IDENT shift to state 104
+
+State 104:
+const_decl -> CONST IDENT . COLON typ EQUAL expr [ NODE EOF CONST ]
+-- On COLON shift to state 105
+
+State 105:
+const_decl -> CONST IDENT COLON . typ EQUAL expr [ NODE EOF CONST ]
+-- On REAL shift to state 6
+-- On INT shift to state 7
+-- On BOOL shift to state 8
+-- On typ shift to state 106
+
+State 106:
+const_decl -> CONST IDENT COLON typ . EQUAL expr [ NODE EOF CONST ]
+-- On EQUAL shift to state 107
+
+State 107:
+const_decl -> CONST IDENT COLON typ EQUAL . expr [ NODE EOF CONST ]
+-- On TRUE shift to state 26
+-- On PLUS shift to state 27
+-- On NOT shift to state 28
+-- On MINUS shift to state 29
+-- On LPAREN shift to state 30
+-- On INTVAL shift to state 31
+-- On IF shift to state 32
+-- On IDENT shift to state 33
+-- On FALSE shift to state 35
+-- On unary_expr shift to state 36
+-- On primary_expr shift to state 38
+-- On if_expr shift to state 41
+-- On expr shift to state 108
+-- On binary_expr shift to state 45
+
+State 108:
+const_decl -> CONST IDENT COLON typ EQUAL expr . [ NODE EOF CONST ]
+-- On NODE reduce production const_decl -> CONST IDENT COLON typ EQUAL expr 
+-- On EOF reduce production const_decl -> CONST IDENT COLON typ EQUAL expr 
+-- On CONST reduce production const_decl -> CONST IDENT COLON typ EQUAL expr 
+
+State 109:
+list(toplevel) -> toplevel . list(toplevel) [ EOF ]
+-- On NODE shift to state 1
+-- On CONST shift to state 103
+-- On toplevel shift to state 109
+-- On node_decl shift to state 110
+-- On list(toplevel) shift to state 111
+-- On const_decl shift to state 112
+-- On EOF reduce production list(toplevel) -> 
+
+State 110:
+toplevel -> node_decl . [ NODE EOF CONST ]
+-- On NODE reduce production toplevel -> node_decl 
+-- On EOF reduce production toplevel -> node_decl 
+-- On CONST reduce production toplevel -> node_decl 
+
+State 111:
+list(toplevel) -> toplevel list(toplevel) . [ EOF ]
+-- On EOF reduce production list(toplevel) -> toplevel list(toplevel) 
+
+State 112:
+toplevel -> const_decl . [ NODE EOF CONST ]
+-- On NODE reduce production toplevel -> const_decl 
+-- On EOF reduce production toplevel -> const_decl 
+-- On CONST reduce production toplevel -> const_decl 
+
+State 113:
+file -> list(toplevel) . EOF [ # ]
+-- On EOF shift to state 114
+
+State 114:
+file -> list(toplevel) EOF . [ # ]
+-- On # reduce production file -> list(toplevel) EOF 
+
+State 115:
+file' -> file . [ # ]
+-- On # accept file
+
diff --git a/frontend/parser.conflicts b/frontend/parser.conflicts
new file mode 100644
index 0000000..296156a
--- /dev/null
+++ b/frontend/parser.conflicts
@@ -0,0 +1,32 @@
+
+** Conflict (shift/reduce) in state 17.
+** Token involved: IDENT
+** This state is reached from file after reading:
+
+NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN VAR var SEMICOLON 
+
+** The derivations that appear below have the following common factor:
+** (The question mark symbol (?) represents the spot where the derivations begin to differ.)
+
+file 
+list(toplevel) EOF 
+toplevel list(toplevel) 
+node_decl 
+(?)
+
+** In state 17, looking ahead at IDENT, reducing production
+** nonempty_list(terminated(var,SEMICOLON)) -> var SEMICOLON 
+** is permitted because of the following sub-derivation:
+
+NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody // lookahead token appears because dbody can begin with IDENT
+                                                  VAR nonempty_list(terminated(var,SEMICOLON)) // lookahead token is inherited
+                                                      var SEMICOLON . 
+
+** In state 17, looking ahead at IDENT, shifting is permitted
+** because of the following sub-derivation:
+
+NODE IDENT LPAREN vars RPAREN RETURNS vars RPAREN var_decl dbody 
+                                                  VAR nonempty_list(terminated(var,SEMICOLON)) 
+                                                      var SEMICOLON nonempty_list(terminated(var,SEMICOLON)) 
+                                                                    var SEMICOLON 
+                                                                    . IDENT COLON typ 
diff --git a/frontend/parser.mly b/frontend/parser.mly
new file mode 100644
index 0000000..9db1bd5
--- /dev/null
+++ b/frontend/parser.mly
@@ -0,0 +1,221 @@
+%{
+open Ast
+%}
+
+/* tokens */
+/**********/
+
+%token BOOL
+%token INT
+%token REAL
+%token PROBE
+%token TRUE
+%token THEN
+%token FALSE
+%token IF
+%token ELSE
+%token NOT
+%token AND
+%token OR
+%token MOD
+%token CONST
+%token NODE
+%token RETURNS
+%token VAR
+%token LET
+%token TEL
+%token PRE
+%token ASSUME
+%token GUARANTEE
+
+%token LPAREN
+%token RPAREN
+%token LCURLY
+%token RCURLY
+%token STAR
+%token PLUS
+%token MINUS
+%token EXCLAIM
+%token DIVIDE
+%token PERCENT
+%token LESS
+%token GREATER
+%token LESS_EQUAL
+%token GREATER_EQUAL
+%token EQUAL_EQUAL
+%token DIFF
+%token AND_AND
+%token BAR_BAR
+%token SEMICOLON
+%token COLON
+%token COMMA
+%token EQUAL
+%token ARROW
+
+%token <string> IDENT
+%token <string> INTVAL
+
+%token EOF
+
+/* priorities of binary operators (lowest to highest) */
+%left ARROW
+%left OR
+%left AND
+%left EQUAL DIFF
+%left LESS GREATER LESS_EQUAL GREATER_EQUAL
+%left PLUS MINUS
+%left STAR DIVIDE MOD
+
+
+/* entry-points */
+/****************/
+
+%start<Ast.toplevel list> file
+
+
+%%
+
+
+/* toplevel */
+/************/
+
+file: t=list(toplevel) EOF { t }
+
+toplevel:
+| d=ext(const_decl)           { AST_const_decl d }
+| d=ext(node_decl)       { AST_node_decl d }
+
+
+/* expressions */
+/***************/
+
+primary_expr:
+| LPAREN e=expr RPAREN     { e }
+| e=ext(IDENT)                    { AST_identifier e }
+| e=ext(INTVAL)                   { AST_int_const e }
+| TRUE                         { AST_bool_const true }
+| FALSE                        { AST_bool_const false }
+| e=ext(IDENT) LPAREN l=separated_list(COMMA,ext(expr)) RPAREN 
+   { AST_instance (e, l) }
+
+
+unary_expr:
+| e=primary_expr                   { e }
+| o=unary_op e=ext(unary_expr)     { AST_unary (o, e) }
+
+%inline unary_op:
+| PLUS          { AST_UPLUS }
+| MINUS         { AST_UMINUS }
+| NOT           { AST_NOT }
+| PRE           { AST_PRE }
+
+
+binary_expr:
+| e=unary_expr                                        { e }
+| e=ext(binary_expr) o=binary_op f=ext(binary_expr)   { AST_binary (o, e, f) }
+
+%inline binary_op:
+| STAR           { AST_MUL }
+| DIVIDE         { AST_DIV }
+| MOD            { AST_MOD }
+| PLUS           { AST_PLUS }
+| MINUS          { AST_MINUS }
+| LESS           { AST_LT }
+| GREATER        { AST_GT }
+| LESS_EQUAL     { AST_LE }
+| GREATER_EQUAL  { AST_GE }
+| EQUAL          { AST_EQ}
+| DIFF           { AST_NE }
+| AND            { AST_AND }
+| OR             { AST_OR }
+| ARROW          { AST_ARROW }
+
+if_expr:
+| IF c=ext(expr) THEN t=ext(expr) ELSE e=ext(expr)
+    { AST_if(c, t, e) }
+| e=binary_expr { e }
+
+expr:
+| e=if_expr { e }
+
+lvalue:
+| i=IDENT   { i }
+
+
+/* equations */
+/****************/
+
+eqn:
+| i=ext(lvalue) EQUAL e=ext(expr)
+    { AST_assign(i, e) }
+| ASSUME i=ext(IDENT) COLON e=ext(expr)
+    { AST_assume(i, e) }
+| GUARANTEE i=ext(IDENT) COLON e=ext(expr)
+    { AST_guarantee(i, e) }
+
+typ:
+| INT    { AST_TINT }
+| BOOL   { AST_TBOOL }
+| REAL   { AST_TREAL }
+
+dbody:
+| e=ext(eqn) SEMICOLON
+    { [e] }
+| LET l=nonempty_list(terminated(ext(eqn), SEMICOLON)) TEL
+    { l }
+
+/* declarations */
+
+var:
+|   p=boption(PROBE) i=ext(IDENT)
+    { (p, i) }
+
+vari:
+|   vn=separated_list(COMMA, var) COLON t=typ
+    { List.map (fun (p, i) -> (p, i, t)) vn }
+
+vars:
+| v=separated_list(SEMICOLON, vari)
+    { List.flatten v }
+
+const_decl:
+| CONST i=ext(IDENT) COLON t=typ EQUAL e=ext(expr) SEMICOLON
+    { (i, t, e) }
+
+var_decl:
+| VAR l=nonempty_list(terminated(vari, SEMICOLON))
+    { List.flatten l }
+
+node_decl:
+| NODE id=IDENT
+    LPAREN v=vars RPAREN
+    RETURNS LPAREN rv=vars RPAREN
+    e = dbody
+    { { name = id;
+        args = v;
+        ret = rv;
+        var = [];
+        body = e;
+    } }
+| NODE id=IDENT
+    LPAREN v=vars RPAREN
+    RETURNS LPAREN rv=vars RPAREN
+    lv=var_decl
+    LET b=nonempty_list(terminated(ext(eqn), SEMICOLON)) TEL
+    { { name = id;
+        args = v;
+        ret = rv;
+        var = lv;
+        body = b;
+    } }
+
+
+/* utilities */
+/*************/
+
+/* adds extent information to rule */
+%inline ext(X): 
+| x=X { x, ($startpos, $endpos) }
+
+
+%%
diff --git a/libs/mapext.ml b/libs/mapext.ml
new file mode 100644
index 0000000..51f41ee
--- /dev/null
+++ b/libs/mapext.ml
@@ -0,0 +1,741 @@
+(*
+  Cours "Sémantique et Application à la Vérification de programmes"
+  
+  Antoine Miné 2014
+  Ecole normale supérieure, Paris, France / CNRS / INRIA
+*)
+  
+(*  
+  This file is derived from the map.ml file from the OCaml distribution.
+  Changes are marked with the [AM] symbol.
+  Based on rev. 10468 2010-05-25 13:29:43Z
+
+  Original copyright follows.
+*)
+
+(***********************************************************************)
+(*                                                                     *)
+(*                           Objective Caml                            *)
+(*                                                                     *)
+(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
+(*                                                                     *)
+(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
+(*  en Automatique.  All rights reserved.  This file is distributed    *)
+(*  under the terms of the GNU Library General Public License, with    *)
+(*  the special exception on linking described in file ../LICENSE.     *)
+(*                                                                     *)
+(***********************************************************************)
+
+module type OrderedType =
+  sig
+    type t
+    val compare: t -> t -> int
+  end
+
+module type S =
+  sig
+    type key
+    type +'a t
+    val empty: 'a t
+    val is_empty: 'a t -> bool
+    val mem:  key -> 'a t -> bool
+    val add: key -> 'a -> 'a t -> 'a t
+    val singleton: key -> 'a -> 'a t
+    val remove: key -> 'a t -> 'a t
+    val merge: (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+    val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
+    val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    val iter: (key -> 'a -> unit) -> 'a t -> unit
+    val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+    val for_all: (key -> 'a -> bool) -> 'a t -> bool
+    val exists: (key -> 'a -> bool) -> 'a t -> bool
+    val filter: (key -> 'a -> bool) -> 'a t -> 'a t
+    val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+    val cardinal: 'a t -> int
+    val bindings: 'a t -> (key * 'a) list
+    val min_binding: 'a t -> (key * 'a)
+    val max_binding: 'a t -> (key * 'a)
+    val choose: 'a t -> (key * 'a)
+    val split: key -> 'a t -> 'a t * 'a option * 'a t
+    val find: key -> 'a t -> 'a
+    val map: ('a -> 'b) -> 'a t -> 'b t
+    val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
+
+
+    (* [AM] additions by Antoine Mine' *)
+
+    val of_list: (key * 'a) list -> 'a t
+
+    val map2: (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
+    val iter2: (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
+    val fold2: (key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
+    val for_all2: (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+    val exists2: (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+
+    val map2z: (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
+    val iter2z: (key -> 'a -> 'a -> unit) -> 'a t -> 'a t -> unit
+    val fold2z: (key -> 'a -> 'a -> 'b -> 'b) -> 'a t -> 'a t -> 'b -> 'b
+    val for_all2z: (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    val exists2z: (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+
+    val map2o: (key -> 'a -> 'c) -> (key -> 'b -> 'c) -> (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
+    val iter2o: (key -> 'a -> unit) -> (key -> 'b -> unit) -> (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
+    val fold2o: (key -> 'a -> 'c -> 'c) -> (key -> 'b -> 'c -> 'c) -> (key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
+    val for_all2o: (key -> 'a -> bool) -> (key -> 'b -> bool) -> (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+    val exists2o: (key -> 'a -> bool) -> (key -> 'b -> bool) -> (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+
+    val map2zo: (key -> 'a -> 'a) -> (key -> 'a -> 'a) -> (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
+    val iter2zo: (key -> 'a -> unit) -> (key -> 'a -> unit) -> (key -> 'a -> 'a -> unit) -> 'a t -> 'a t -> unit
+    val fold2zo: (key -> 'a -> 'b -> 'b) -> (key -> 'a -> 'b -> 'b) -> (key -> 'a -> 'a -> 'b -> 'b) -> 'a t -> 'a t -> 'b -> 'b
+    val for_all2zo: (key -> 'a -> bool) -> (key -> 'a -> bool) -> (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+     val exists2zo: (key -> 'a -> bool) -> (key -> 'a -> bool) -> (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+
+    val map_slice: (key -> 'a -> 'a) -> 'a t -> key -> key -> 'a t
+    val iter_slice: (key -> 'a -> unit) -> 'a t -> key -> key -> unit
+    val fold_slice: (key -> 'a -> 'b -> 'b) -> 'a t -> key -> key -> 'b -> 'b
+    val for_all_slice: (key -> 'a -> bool) -> 'a t -> key -> key -> bool
+    val exists_slice: (key -> 'a -> bool) -> 'a t -> key -> key -> bool
+
+    val key_equal: 'a t -> 'a t -> bool
+    val key_subset: 'a t -> 'a t -> bool
+
+    val find_greater: key -> 'a t -> key * 'a
+    val find_less: key -> 'a t -> key * 'a
+    val find_greater_equal: key -> 'a t -> key * 'a
+    val find_less_equal: key -> 'a t -> key * 'a
+
+  end
+
+module Make(Ord: OrderedType) = (struct
+
+    type key = Ord.t
+
+    type 'a t =
+        Empty
+      | Node of 'a t * key * 'a * 'a t * int
+
+    let height = function
+        Empty -> 0
+      | Node(_,_,_,_,h) -> h
+
+    let create l x d r =
+      let hl = height l and hr = height r in
+      Node(l, x, d, r, (if hl >= hr then hl + 1 else hr + 1))
+
+    let singleton x d = Node(Empty, x, d, Empty, 1)
+
+    let bal l x d r =
+      let hl = match l with Empty -> 0 | Node(_,_,_,_,h) -> h in
+      let hr = match r with Empty -> 0 | Node(_,_,_,_,h) -> h in
+      if hl > hr + 2 then begin
+        match l with
+          Empty -> invalid_arg "Mapext.bal"
+        | Node(ll, lv, ld, lr, _) ->
+            if height ll >= height lr then
+              create ll lv ld (create lr x d r)
+            else begin
+              match lr with
+                Empty -> invalid_arg "Mapext.bal"
+              | Node(lrl, lrv, lrd, lrr, _)->
+                  create (create ll lv ld lrl) lrv lrd (create lrr x d r)
+            end
+      end else if hr > hl + 2 then begin
+        match r with
+          Empty -> invalid_arg "Mapext.bal"
+        | Node(rl, rv, rd, rr, _) ->
+            if height rr >= height rl then
+              create (create l x d rl) rv rd rr
+            else begin
+              match rl with
+                Empty -> invalid_arg "Mapext.bal"
+              | Node(rll, rlv, rld, rlr, _) ->
+                  create (create l x d rll) rlv rld (create rlr rv rd rr)
+            end
+      end else
+        Node(l, x, d, r, (if hl >= hr then hl + 1 else hr + 1))
+
+    let empty = Empty
+
+    let is_empty = function Empty -> true | _ -> false
+
+    let rec add x data = function
+        Empty ->
+          Node(Empty, x, data, Empty, 1)
+      | Node(l, v, d, r, h) ->
+          let c = Ord.compare x v in
+          if c = 0 then
+            Node(l, x, data, r, h)
+          else if c < 0 then
+            bal (add x data l) v d r
+          else
+            bal l v d (add x data r)
+
+    let rec find x = function
+        Empty ->
+          raise Not_found
+      | Node(l, v, d, r, _) ->
+          let c = Ord.compare x v in
+          if c = 0 then d
+          else find x (if c < 0 then l else r)
+
+    let rec mem x = function
+        Empty ->
+          false
+      | Node(l, v, d, r, _) ->
+          let c = Ord.compare x v in
+          c = 0 || mem x (if c < 0 then l else r)
+
+    let rec min_binding = function
+        Empty -> raise Not_found
+      | Node(Empty, x, d, r, _) -> (x, d)
+      | Node(l, x, d, r, _) -> min_binding l
+
+    let rec max_binding = function
+        Empty -> raise Not_found
+      | Node(l, x, d, Empty, _) -> (x, d)
+      | Node(l, x, d, r, _) -> max_binding r
+
+    let rec remove_min_binding = function
+        Empty -> invalid_arg "Mapext.remove_min_elt"
+      | Node(Empty, x, d, r, _) -> r
+      | Node(l, x, d, r, _) -> bal (remove_min_binding l) x d r
+
+    let merge t1 t2 =
+      match (t1, t2) with
+        (Empty, t) -> t
+      | (t, Empty) -> t
+      | (_, _) ->
+          let (x, d) = min_binding t2 in
+          bal t1 x d (remove_min_binding t2)
+
+    let rec remove x = function
+        Empty ->
+          Empty
+      | Node(l, v, d, r, h) ->
+          let c = Ord.compare x v in
+          if c = 0 then
+            merge l r
+          else if c < 0 then
+            bal (remove x l) v d r
+          else
+            bal l v d (remove x r)
+
+    let rec iter f = function
+        Empty -> ()
+      | Node(l, v, d, r, _) ->
+          iter f l; f v d; iter f r
+
+    let rec map f = function
+        Empty ->
+          Empty
+      | Node(l, v, d, r, h) ->
+          let l' = map f l in
+          let d' = f d in
+          let r' = map f r in
+          Node(l', v, d', r', h)
+
+    let rec mapi f = function
+        Empty ->
+          Empty
+      | Node(l, v, d, r, h) ->
+          let l' = mapi f l in
+          let d' = f v d in
+          let r' = mapi f r in
+          Node(l', v, d', r', h)
+
+    let rec fold f m accu =
+      match m with
+        Empty -> accu
+      | Node(l, v, d, r, _) ->
+          fold f r (f v d (fold f l accu))
+
+    (* [AM] changed to call p in the key order *)
+    let rec for_all p = function
+        Empty -> true
+      | Node(l, v, d, r, _) -> for_all p l && p v d && for_all p r
+
+    (* [AM] changed to call p in the key order *)
+    let rec exists p = function
+        Empty -> false
+      | Node(l, v, d, r, _) -> exists p l || p v d || exists p r
+
+    (* [AM] changed to call p in the key order *)
+    let filter p s =
+      fold (fun k d a -> if p k d then add k d a else a) s Empty
+
+    let partition p s =
+      let rec part (t, f as accu) = function
+        | Empty -> accu
+        | Node(l, v, d, r, _) ->
+            part (part (if p v d then (add v d t, f) else (t, add v d f)) l) r in
+      part (Empty, Empty) s
+
+    (* Same as create and bal, but no assumptions are made on the
+       relative heights of l and r. *)
+
+    let rec join l v d r =
+      match (l, r) with
+        (Empty, _) -> add v d r
+      | (_, Empty) -> add v d l
+      | (Node(ll, lv, ld, lr, lh), Node(rl, rv, rd, rr, rh)) ->
+          if lh > rh + 2 then bal ll lv ld (join lr v d r) else
+          if rh > lh + 2 then bal (join l v d rl) rv rd rr else
+          create l v d r
+
+    (* Merge two trees l and r into one.
+       All elements of l must precede the elements of r.
+       No assumption on the heights of l and r. *)
+
+    let concat t1 t2 =
+      match (t1, t2) with
+        (Empty, t) -> t
+      | (t, Empty) -> t
+      | (_, _) ->
+          let (x, d) = min_binding t2 in
+          join t1 x d (remove_min_binding t2)
+
+    let concat_or_join t1 v d t2 =
+      match d with
+      | Some d -> join t1 v d t2
+      | None -> concat t1 t2
+
+    let rec split x = function
+        Empty ->
+          (Empty, None, Empty)
+      | Node(l, v, d, r, _) ->
+          let c = Ord.compare x v in
+          if c = 0 then (l, Some d, r)
+          else if c < 0 then
+            let (ll, pres, rl) = split x l in (ll, pres, join rl v d r)
+          else
+            let (lr, pres, rr) = split x r in (join l v d lr, pres, rr)
+
+    let rec merge f s1 s2 =
+      match (s1, s2) with
+        (Empty, Empty) -> Empty
+      | (Node (l1, v1, d1, r1, h1), _) when h1 >= height s2 ->
+          let (l2, d2, r2) = split v1 s2 in
+          concat_or_join (merge f l1 l2) v1 (f v1 (Some d1) d2) (merge f r1 r2)
+      | (_, Node (l2, v2, d2, r2, h2)) ->
+          let (l1, d1, r1) = split v2 s1 in
+          concat_or_join (merge f l1 l2) v2 (f v2 d1 (Some d2)) (merge f r1 r2)
+      | _ ->
+          assert false
+
+    type 'a enumeration = End | More of key * 'a * 'a t * 'a enumeration
+
+    let rec cons_enum m e =
+      match m with
+        Empty -> e
+      | Node(l, v, d, r, _) -> cons_enum l (More(v, d, r, e))
+
+    let compare cmp m1 m2 =
+      let rec compare_aux e1 e2 =
+          match (e1, e2) with
+          (End, End) -> 0
+        | (End, _)  -> -1
+        | (_, End) -> 1
+        | (More(v1, d1, r1, e1), More(v2, d2, r2, e2)) ->
+            let c = Ord.compare v1 v2 in
+            if c <> 0 then c else
+            let c = cmp d1 d2 in
+            if c <> 0 then c else
+            compare_aux (cons_enum r1 e1) (cons_enum r2 e2)
+      in compare_aux (cons_enum m1 End) (cons_enum m2 End)
+
+    let equal cmp m1 m2 =
+      let rec equal_aux e1 e2 =
+          match (e1, e2) with
+          (End, End) -> true
+        | (End, _)  -> false
+        | (_, End) -> false
+        | (More(v1, d1, r1, e1), More(v2, d2, r2, e2)) ->
+            Ord.compare v1 v2 = 0 && cmp d1 d2 &&
+            equal_aux (cons_enum r1 e1) (cons_enum r2 e2)
+      in equal_aux (cons_enum m1 End) (cons_enum m2 End)
+
+    let rec cardinal = function
+        Empty -> 0
+      | Node(l, _, _, r, _) -> cardinal l + 1 + cardinal r
+
+    let rec bindings_aux accu = function
+        Empty -> accu
+      | Node(l, v, d, r, _) -> bindings_aux ((v, d) :: bindings_aux accu r) l
+
+    let bindings s =
+      bindings_aux [] s
+
+    let choose = min_binding
+
+
+
+    (* [AM] additions by Antoine Mine' *)
+    (* ******************************* *)
+
+
+    let of_list l =
+      List.fold_left (fun acc (k,x) -> add k x acc) empty l
+
+
+    (* similar to split, but returns unbalanced trees *)
+    let rec cut k = function
+      Empty -> Empty,None,Empty
+    | Node (l1,k1,d1,r1,h1) ->
+        let c = Ord.compare k k1 in
+        if c < 0 then 
+          let l2,d2,r2 = cut k l1 in (l2,d2,Node (r2,k1,d1,r1,h1))
+        else if c > 0 then
+          let l2,d2,r2 = cut k r1 in (Node (l1,k1,d1,l2,h1),d2,r2)
+        else (l1,Some d1,r1)
+
+
+    (* binary operations that fail on maps with different keys *)
+
+    (* functions are called in increasing key order *)
+
+    let rec map2 f m1 m2 =
+      match m1 with
+      | Empty -> if m2 = Empty then Empty else invalid_arg "Mapext.map2"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 ->
+              Node (map2 f l1 l2, k, f k d1 d2, map2 f r1 r2, h1)
+          | _, None, _ -> invalid_arg "Mapext.map2"
+            
+    let rec iter2 f m1 m2 =
+      match m1 with
+      | Empty -> if m2 = Empty then () else invalid_arg "Mapext.iter2"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> iter2 f l1 l2; f k d1 d2; iter2 f r1 r2
+          | _, None, _ -> invalid_arg "Mapext.iter2"
+            
+    let rec fold2 f m1 m2 acc =
+      match m1 with
+      | Empty -> if m2 = Empty then acc else invalid_arg "Mapext.fold2"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              fold2 f r1 r2 (f k d1 d2 (fold2 f l1 l2 acc))
+          | _, None, _ -> invalid_arg "Mapext.fold2"
+            
+    let rec for_all2 f m1 m2 =
+      match m1 with
+      | Empty -> if m2 = Empty then true else invalid_arg "Mapext.for_all2"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              for_all2 f l1 l2 && f k d1 d2 && for_all2 f r1 r2
+          | _, None, _ -> invalid_arg "Mapext.for_all2"
+            
+    let rec exists2 f m1 m2 =
+      match m1 with
+      | Empty -> if m2 = Empty then false else invalid_arg "Mapext.exists2"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              exists2 f l1 l2 || f k d1 d2 || exists2 f r1 r2
+          | _, None, _ -> invalid_arg "Mapext.exists2"
+            
+
+    (* as above, but ignore physically equal subtrees
+       - for map, assumes: f k d d = d
+       - for iter, assumes: f k d d has no effect
+       - for fold, assumes: k f d d acc = acc
+       - for for_all, assumes: f k d d = true
+       - for exists, assumes: f k d d = false
+     *)
+
+    let rec map2z f m1 m2 =
+      if m1 == m2 then m1 else
+      match m1 with
+      | Empty -> if m2 = Empty then Empty else invalid_arg "Mapext.map2z"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 ->
+              let d = if d1 == d2 then d1 else f k d1 d2 in
+              Node (map2z f l1 l2, k, d, map2z f r1 r2, h1)
+          | _, None, _ -> invalid_arg "Mapext.map2z"
+            
+    let rec iter2z f m1 m2 =
+      if m1 == m2 then () else
+      match m1 with
+      | Empty -> if m2 = Empty then () else invalid_arg "Mapext.iter2z"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              iter2z f l1 l2; (if d1 != d2 then f k d1 d2); iter2z f r1 r2
+          | _, None, _ -> invalid_arg "Mapext.iter2z"
+            
+    let rec fold2z f m1 m2 acc =
+      if m1 == m2 then acc else
+      match m1 with
+      | Empty -> if m2 = Empty then acc else invalid_arg "Mapext.fold2z"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              let acc = fold2z f l1 l2 acc in
+              let acc = if d1 == d2 then acc else f k d1 d2 acc in
+              fold2z f r1 r2 acc
+          | _, None, _ -> invalid_arg "Mapext.fold2z"
+            
+    let rec for_all2z f m1 m2 =
+      (m1 == m2) ||
+      (match m1 with
+      | Empty -> if m2 = Empty then true else invalid_arg "Mapext.for_all2z"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              (for_all2z f l1 l2) && 
+              (d1 == d2 || f k d1 d2) && 
+              (for_all2z f r1 r2)
+          | _, None, _ -> invalid_arg "Mapext.for_all2z"
+      )     
+            
+    let rec exists2z f m1 m2 =
+      (m1 != m2) &&
+      (match m1 with
+      | Empty -> if m2 = Empty then false else invalid_arg "Mapext.exists2z"
+      | Node (l1,k,d1,r1,h1) ->
+          match cut k m2 with 
+          | l2, Some d2, r2 -> 
+              (exists2z f l1 l2) ||
+              (d1 != d2 && f k d1 d2) ||
+              (exists2z f r1 r2)
+          | _, None, _ -> invalid_arg "Mapext.exists2z"
+      )     
+
+
+    (* as above, but allow maps with different keys *)
+
+    let rec map2o f1 f2 f m1 m2 =
+      match m1 with
+      | Empty -> mapi f2 m2
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          let l = map2o f1 f2 f l1 l2 in
+          let d = match d2 with None -> f1 k d1 | Some d2 -> f k d1 d2 in
+          let r = map2o f1 f2 f r1 r2 in
+          join l k d r
+            
+    let rec iter2o f1 f2 f m1 m2 =
+      match m1 with
+      | Empty -> iter f2 m2
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          iter2o f1 f2 f l1 l2;
+          (match d2 with None -> f1 k d1 | Some d2 -> f k d1 d2);
+          iter2o f1 f2 f r1 r2
+            
+    let rec fold2o f1 f2 f m1 m2 acc =
+      match m1 with
+      | Empty -> fold f2 m2 acc
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          let acc = fold2o f1 f2 f l1 l2 acc in
+          let acc = match d2 with 
+          | None -> f1 k d1 acc | Some d2 -> f k d1 d2 acc
+          in
+          fold2o f1 f2 f r1 r2 acc
+            
+    let rec for_all2o f1 f2 f m1 m2 =
+      match m1 with
+      | Empty -> for_all f2 m2 
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          (for_all2o f1 f2 f l1 l2) &&
+          (match d2 with None -> f1 k d1 | Some d2 -> f k d1 d2) &&
+          (for_all2o f1 f2 f r1 r2)
+
+    let rec exists2o f1 f2 f m1 m2 =
+      match m1 with
+      | Empty -> exists f2 m2 
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          (exists2o f1 f2 f l1 l2) ||
+          (match d2 with None -> f1 k d1 | Some d2 -> f k d1 d2) ||
+          (exists2o f1 f2 f r1 r2)
+
+
+    (* all together now *)
+
+    let rec map2zo f1 f2 f m1 m2 =
+      if m1 == m2 then m1 else
+      match m1 with
+      | Empty -> mapi f2 m2
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          let l = map2zo f1 f2 f l1 l2 in
+          let d = match d2 with 
+          | None -> f1 k d1 
+          | Some d2 -> if d1 == d2 then d1 else f k d1 d2 
+          in
+          let r = map2zo f1 f2 f r1 r2 in
+          join l k d r
+            
+    let rec iter2zo f1 f2 f m1 m2 =
+      if m1 == m2 then () else
+      match m1 with
+      | Empty -> iter f2 m2
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          iter2zo f1 f2 f l1 l2;
+          (match d2 with 
+          | None -> f1 k d1 
+          | Some d2 -> if d1 != d2 then f k d1 d2);
+          iter2zo f1 f2 f r1 r2
+            
+    let rec fold2zo f1 f2 f m1 m2 acc =
+      if m1 == m2 then acc else
+      match m1 with
+      | Empty -> fold f2 m2 acc
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          let acc = fold2zo f1 f2 f l1 l2 acc in
+          let acc = match d2 with 
+          | None -> f1 k d1 acc 
+          | Some d2 -> if d1 == d2 then acc else f k d1 d2 acc
+          in
+          fold2zo f1 f2 f r1 r2 acc
+            
+    let rec for_all2zo f1 f2 f m1 m2 =
+      (m1 == m2) ||
+      (match m1 with
+      | Empty -> for_all f2 m2 
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          (for_all2zo f1 f2 f l1 l2) &&
+          (match d2 with None -> f1 k d1 | Some d2 -> d1 == d2 || f k d1 d2) &&
+          (for_all2zo f1 f2 f r1 r2)
+      )
+
+    let rec exists2zo f1 f2 f m1 m2 =
+      (m1 != m2) &&
+      (match m1 with
+      | Empty -> exists f2 m2 
+      | Node (l1,k,d1,r1,h1) ->
+          let l2, d2, r2 = cut k m2 in
+          (exists2zo f1 f2 f l1 l2) ||
+          (match d2 with None -> f1 k d1 | Some d2 -> d1 != d2 && f k d1 d2) ||
+          (exists2zo f1 f2 f r1 r2)
+      )
+
+
+    (* iterators limited to keys between two bounds *)
+
+    let rec map_slice f m lo hi =
+      match m with
+      | Empty -> Empty
+      | Node (l,k,d,r,h) ->
+          let c1, c2 = Ord.compare k lo, Ord.compare k hi in
+          let l = if c1 > 0 then map_slice f l lo k else l in
+          let d = if c1 >= 0 && c2 <= 0 then f k d else d in
+          let r = if c2 < 0 then map_slice f r k hi else r in
+          Node (l,k,d,r,h)
+
+    let rec iter_slice f m lo hi =
+      match m with
+      | Empty -> ()
+      | Node (l,k,d,r,_) ->
+          let c1, c2 = Ord.compare k lo, Ord.compare k hi in
+          if c1 > 0 then iter_slice f l lo k;
+          if c1 >= 0 && c2 <= 0 then f k d;
+          if c2 < 0 then iter_slice f r k hi
+
+    let rec fold_slice f m lo hi acc =
+      match m with
+      | Empty -> acc
+      | Node (l,k,d,r,_) ->
+          let c1, c2 = Ord.compare k lo, Ord.compare k hi in
+          let acc = if c1 > 0 then fold_slice f l lo k acc else acc in
+          let acc = if c1 >= 0 && c2 <= 0 then f k d acc else acc in
+          if c2 < 0 then fold_slice f r k hi acc else acc
+
+    let rec for_all_slice f m lo hi =
+      match m with
+      | Empty -> true
+      | Node (l,k,d,r,_) ->
+          let c1, c2 = Ord.compare k lo, Ord.compare k hi in
+          (c1 <= 0 || for_all_slice f l lo k) &&
+          (c1 < 0 || c2 > 0 || f k d) &&
+          (c2 >= 0 || for_all_slice f r k hi)
+
+    let rec exists_slice f m lo hi =
+      match m with
+      | Empty -> false
+      | Node (l,k,d,r,_) ->
+          let c1, c2 = Ord.compare k lo, Ord.compare k hi in
+          (c1 > 0 && exists_slice f l lo k) ||
+          (c1 >= 0 && c2 <= 0 && f k d) ||
+          (c2 < 0 && exists_slice f r k hi)
+
+
+    (* key set comparison *)
+
+    let rec key_equal m1 m2 =
+      (m1 == m2) || 
+      (match m1 with
+      | Empty -> m2 = Empty
+      | Node (l1, k, _, r1, _) ->
+          match cut k m2 with
+          | _, None, _ -> false
+          | l2, Some _, r2 -> key_equal l1 l2 && key_equal r1 r2
+      )
+
+    let rec key_subset m1 m2 =
+      (m1 == m2) || 
+      (match m1 with
+      | Empty -> true
+      | Node (l1, k, _, r1, _) ->
+          match cut k m2 with
+          | _, None, _ -> false
+          | l2, Some _, r2 -> key_subset l1 l2 && key_subset r1 r2
+      )
+
+
+    (* nagivation *)
+
+    let find_greater_equal k m =
+      let rec aux m found = match m with
+      | Empty -> (match found with None -> raise Not_found | Some x -> x)
+      | Node (l, kk, d, r, _) ->
+          let c = Ord.compare k kk in
+          if c = 0 then kk, d else
+          if c > 0 then aux r found else
+          aux l (Some (kk, d))
+      in
+      aux m None 
+
+    let find_greater k m =
+      let rec aux m found = match m with
+      | Empty -> (match found with None -> raise Not_found | Some x -> x)
+      | Node (l, kk, d, r, _) ->
+          let c = Ord.compare k kk in
+          if c >= 0 then aux r found else
+          aux l (Some (kk, d))
+      in
+      aux m None 
+
+    let find_less_equal k m =
+      let rec aux m found = match m with
+      | Empty -> (match found with None -> raise Not_found | Some x -> x)
+      | Node (l, kk, d, r, _) ->
+          let c = Ord.compare k kk in
+          if c = 0 then kk, d else
+          if c < 0 then aux l found else
+          aux r (Some (kk, d))
+      in
+      aux m None 
+
+    let find_less k m =
+      let rec aux m found = match m with
+      | Empty -> (match found with None -> raise Not_found | Some x -> x)
+      | Node (l, kk, d, r, _) ->
+          let c = Ord.compare k kk in
+          if c <= 0 then aux l found else
+          aux r (Some (kk, d))
+      in
+      aux m None 
+
+
+end: S with type key = Ord.t)
diff --git a/libs/mapext.mli b/libs/mapext.mli
new file mode 100644
index 0000000..abee2c0
--- /dev/null
+++ b/libs/mapext.mli
@@ -0,0 +1,473 @@
+(*
+  Cours "Sémantique et Application à la Vérification de programmes"
+  
+  Antoine Miné 2014
+  Ecole normale supérieure, Paris, France / CNRS / INRIA
+*)
+  
+(*  
+  This file is derived from the mapi.ml file from the OCaml distribution.
+  Changes are marked with the [AM] symbol.
+  Based on rev. 10632 2010-07-24 14:16:58Z.
+
+  Original copyright follows.
+*)
+
+
+(***********************************************************************)
+(*                                                                     *)
+(*                           Objective Caml                            *)
+(*                                                                     *)
+(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
+(*                                                                     *)
+(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
+(*  en Automatique.  All rights reserved.  This file is distributed    *)
+(*  under the terms of the GNU Library General Public License, with    *)
+(*  the special exception on linking described in file ../LICENSE.     *)
+(*                                                                     *)
+(***********************************************************************)
+
+(* $Id: mapext.mli,v 1.1 2014-02-24 16:25:06 mine Exp $ *)
+
+(** Association tables over ordered types.
+
+   This module implements applicative association tables, also known as
+   finite maps or dictionaries, given a total ordering function
+   over the keys.
+   All operations over maps are purely applicative (no side-effects).
+   The implementation uses balanced binary trees, and therefore searching
+   and insertion take time logarithmic in the size of the map.
+*)
+
+module type OrderedType =
+  sig
+    type t
+      (** The type of the map keys. *)
+    val compare : t -> t -> int
+      (** A total ordering function over the keys.
+          This is a two-argument function [f] such that
+          [f e1 e2] is zero if the keys [e1] and [e2] are equal,
+          [f e1 e2] is strictly negative if [e1] is smaller than [e2],
+          and [f e1 e2] is strictly positive if [e1] is greater than [e2].
+          Example: a suitable ordering function is the generic structural
+          comparison function {!Pervasives.compare}. *)
+  end
+(** Input signature of the functor {!Map.Make}. *)
+
+module type S =
+  sig
+    type key
+    (** The type of the map keys. *)
+
+    type (+'a) t
+    (** The type of maps from type [key] to type ['a]. *)
+
+    val empty: 'a t
+    (** The empty map. *)
+
+    val is_empty: 'a t -> bool
+    (** Test whether a map is empty or not. *)
+
+    val mem: key -> 'a t -> bool
+    (** [mem x m] returns [true] if [m] contains a binding for [x],
+       and [false] otherwise. *)
+
+    val add: key -> 'a -> 'a t -> 'a t
+    (** [add x y m] returns a map containing the same bindings as
+       [m], plus a binding of [x] to [y]. If [x] was already bound
+       in [m], its previous binding disappears. *)
+
+    val singleton: key -> 'a -> 'a t
+    (** [singleton x y] returns the one-element map that contains a binding [y]
+        for [x].
+        @since 3.12.0
+     *)
+
+    val remove: key -> 'a t -> 'a t
+    (** [remove x m] returns a map containing the same bindings as
+       [m], except for [x] which is unbound in the returned map. *)
+
+    val merge:
+         (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
+    (** [merge f m1 m2] computes a map whose keys is a subset of keys of [m1]
+        and of [m2]. The presence of each such binding, and the corresponding
+        value, is determined with the function [f].
+        @since 3.12.0
+     *)
+
+    val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
+    (** Total ordering between maps.  The first argument is a total ordering
+        used to compare data associated with equal keys in the two maps. *)
+
+    val equal: ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    (** [equal cmp m1 m2] tests whether the maps [m1] and [m2] are
+       equal, that is, contain equal keys and associate them with
+       equal data.  [cmp] is the equality predicate used to compare
+       the data associated with the keys. *)
+
+    val iter: (key -> 'a -> unit) -> 'a t -> unit
+    (** [iter f m] applies [f] to all bindings in map [m].
+       [f] receives the key as first argument, and the associated value
+       as second argument.  The bindings are passed to [f] in increasing
+       order with respect to the ordering over the type of the keys. *)
+
+    val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
+    (** [fold f m a] computes [(f kN dN ... (f k1 d1 a)...)],
+       where [k1 ... kN] are the keys of all bindings in [m]
+       (in increasing order), and [d1 ... dN] are the associated data. *)
+
+    val for_all: (key -> 'a -> bool) -> 'a t -> bool        
+    (* [AM] now guarantees the evaluation order *)
+    (** [for_all p m] checks if all the bindings of the map
+        satisfy the predicate [p].
+        The predicate [p] is tested on bindings according to the key order.
+        @since 3.12.0
+     *)
+
+    val exists: (key -> 'a -> bool) -> 'a t -> bool
+    (* [AM] now guarantees the evaluation order *)
+    (** [exists p m] checks if at least one binding of the map
+        satisfy the predicate [p].
+        The predicate [p] is tested on bindings according to the key order.
+        @since 3.12.0
+     *)
+
+    val filter: (key -> 'a -> bool) -> 'a t -> 'a t
+    (* [AM] now guarantees the evaluation order *)
+    (** [filter p m] returns the map with all the bindings in [m]
+        that satisfy predicate [p].
+        The predicate [p] is tested on bindings according to the key order.
+        @since 3.12.0
+     *)
+
+    val partition: (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
+    (** [partition p m] returns a pair of maps [(m1, m2)], where
+        [m1] contains all the bindings of [s] that satisfy the
+        predicate [p], and [m2] is the map with all the bindings of
+        [s] that do not satisfy [p].
+        @since 3.12.0
+     *)
+
+    val cardinal: 'a t -> int
+    (** Return the number of bindings of a map.
+        @since 3.12.0
+     *)
+
+    val bindings: 'a t -> (key * 'a) list
+    (** Return the list of all bindings of the given map.
+       The returned list is sorted in increasing order with respect
+       to the ordering [Ord.compare], where [Ord] is the argument
+       given to {!Map.Make}.
+        @since 3.12.0
+     *)
+
+    val min_binding: 'a t -> (key * 'a)
+    (** Return the smallest binding of the given map
+       (with respect to the [Ord.compare] ordering), or raise
+       [Not_found] if the map is empty.
+        @since 3.12.0
+     *)
+
+    val max_binding: 'a t -> (key * 'a)
+    (** Same as {!Map.S.min_binding}, but returns the largest binding
+        of the given map.
+        @since 3.12.0
+     *)
+
+    val choose: 'a t -> (key * 'a)
+    (** Return one binding of the given map, or raise [Not_found] if
+       the map is empty. Which binding is chosen is unspecified,
+       but equal bindings will be chosen for equal maps.
+        @since 3.12.0
+     *)
+
+    val split: key -> 'a t -> 'a t * 'a option * 'a t
+    (** [split x m] returns a triple [(l, data, r)], where
+          [l] is the map with all the bindings of [m] whose key
+        is strictly less than [x];
+          [r] is the map with all the bindings of [m] whose key
+        is strictly greater than [x];
+          [data] is [None] if [m] contains no binding for [x],
+          or [Some v] if [m] binds [v] to [x].
+        @since 3.12.0
+     *)
+
+    val find: key -> 'a t -> 'a
+    (** [find x m] returns the current binding of [x] in [m],
+       or raises [Not_found] if no such binding exists. *)
+
+    val map: ('a -> 'b) -> 'a t -> 'b t
+    (** [map f m] returns a map with same domain as [m], where the
+       associated value [a] of all bindings of [m] has been
+       replaced by the result of the application of [f] to [a].
+       The bindings are passed to [f] in increasing order
+       with respect to the ordering over the type of the keys. *)
+
+    val mapi: (key -> 'a -> 'b) -> 'a t -> 'b t
+    (** Same as {!Map.S.map}, but the function receives as arguments both the
+       key and the associated value for each binding of the map. *)
+
+
+    (* [AM] additions *)
+   
+    (** {2 Additional functions} *)
+
+    val of_list: (key * 'a) list -> 'a t
+    (** [of_list l] converts an association list to a map. *)
+
+    val map2: (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
+    (** [map2 f m1 m2] is similar to [map] but applies [f] to pairs
+       of bindings [a1] from [m1] and [a2] from [m2] corresponding to
+       the same key to construct a new map with the same key set.
+       [m1] and [m2] must have the same key sets.
+       The binging are passed to [f] in increasing order of key. *)
+
+    val iter2: (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
+    (** [iter2 f m1 m2] is similar to [map] but applies [f] to pairs
+       of bindings [a1] from [m1] and [a2] from [m2] corresponding to
+       the same key.
+       [m1] and [m2] must have the same key sets.
+       The binging are passed to [f] in increasing order of key. *)
+
+    val fold2: (key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
+    (** [fold2 f m1 m2 x] is similar to [fold] but applies [f] to pairs
+       of bindings [a1] from [m1] and [a2] from [m2] corresponding to
+       the same key.
+       [m1] and [m2] must have the same key sets.
+       The bindings are passed to [f] in increasing order of keys. *)
+
+    val for_all2: (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+    (** [for_all2 f m1 m2] is similar to [for_all] but applies [f] to pairs
+       of bindings [a1] from [m1] and [a2] from [m2] corresponding to
+       the same key.
+       [m1] and [m2] must have the same key sets.
+       The bindings are passed to [f] in increasing order of keys. *)
+
+    val exists2: (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+    (** [exists2 f m1 m2] is similar to [exists] but applies [f] to pairs
+       of bindings [a1] from [m1] and [a2] from [m2] corresponding to
+       the same key.
+       [m1] and [m2] must have the same key sets.
+       The bindings are passed to [f] in increasing order of keys. *)
+
+
+
+
+    val map2z: (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
+    (** [map2z f m1 m2] is similar to [map2 f m1 m2], but physically
+        equal subtrees are put unchanged into the result instead of
+        being traversed.
+        This is more efficient than [map2], and equivalent if [f] is
+        side-effect free and idem-potent ([f k a a = a]).
+        [m1] and [m2] must have the same key sets.
+        The bindings are passed to [f] in increasing order of keys. *)
+  
+    val iter2z: (key -> 'a -> 'a -> unit) -> 'a t -> 'a t -> unit
+     (** [iter2z f m1 m2] is similar to [iter2 f m1 m2], but physically
+        equal subtrees are ignored.
+        This is more efficient than [iter2], and equivalent if 
+        [f k a a] has no effect.
+        [m1] and [m2] must have the same key sets.
+        The bindings are passed to [f] in increasing order of keys. *)
+
+    val fold2z: (key -> 'a -> 'a -> 'b -> 'b) -> 'a t -> 'a t -> 'b -> 'b
+    (** [fold2z f m1 m2 a] is similar to [fold2 f m1 m2 a], but physically
+        equal subtrees are ignored.
+        This is more efficient than [fold2], and equivalent if 
+        [f k a a x = x] and has no effect.
+        [m1] and [m2] must have the same key sets.
+        The bindings are passed to [f] in increasing order of keys. *)
+
+    val for_all2z: (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    (** [for_all2z f m1 m2] is similar to [for_all2 f m1 m2], but returns
+        [true] for physically equal subtrees without traversing them.
+        This is more efficient than [for_all2z], and equivalent if
+        [f k a a = true] and has no effect.
+        [m1] and [m2] must have the same key sets.
+        The bindings are passed to [f] in increasing order of keys. *)
+
+    val exists2z: (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    (** [exists2z f m1 m2] is similar to [exists2 f m1 m2], but returns
+        [false] for physically equal subtrees without traversing them.
+        This is more efficient than [exists2z], and equivalent if
+        [f k a a = false] and has no effect.
+        [m1] and [m2] must have the same key sets.
+        The bindings are passed to [f] in increasing order of keys. *)
+
+
+
+
+    val map2o: (key -> 'a -> 'c) -> (key -> 'b -> 'c) -> (key -> 'a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
+    (** [map2o f1 f2 f m1 m2] is similar to [map2 f m1 m2], but 
+        accepts maps defined over different sets of keys.
+        To get a new binding, [f1] is used for keys appearing only
+        in [m1], [f2] for keys appearing only in [m2], and [f] for
+        keys appearing in both maps.
+        The returned map has bindings for all keys appearing in either
+        [m1] or [m2].
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+    val iter2o: (key -> 'a -> unit) -> (key -> 'b -> unit) -> (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
+    (** [iter2o f1 f2 f m1 m2] is similar to [iter2 f m1 m2], but 
+        accepts maps defined over different sets of keys.
+        [f1] is called for keys appearing only in [m1], 
+        [f2] for keys appearing only in [m2], 
+        and [f] for keys appearing in both maps.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+    val fold2o: (key -> 'a -> 'c -> 'c) -> (key -> 'b -> 'c -> 'c) -> (key -> 'a -> 'b -> 'c -> 'c) -> 'a t -> 'b t -> 'c -> 'c
+    (** [fold2o f1 f2 f m1 m2 a] is similar to [fold2 f m1 m2 a], but 
+        accepts maps defined over different sets of keys.
+        [f1] is called for keys appearing only in [m1], 
+        [f2] for keys appearing only in [m2], 
+        and [f] for keys appearing in both maps.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+    val for_all2o: (key -> 'a -> bool) -> (key -> 'b -> bool) -> (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+    (** [for_all2o f1 f2 f m1 m2] is similar to [for_all2 f m1 m2], but 
+        accepts maps defined over different sets of keys.
+        [f1] is called for keys appearing only in [m1], 
+        [f2] for keys appearing only in [m2], 
+        and [f] for keys appearing in both maps.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+    val exists2o: (key -> 'a -> bool) -> (key -> 'b -> bool) -> (key -> 'a -> 'b -> bool) -> 'a t -> 'b t -> bool
+    (** [fexists2o f1 f2 f m1 m2] is similar to [fexists2 f m1 m2], but 
+        accepts maps defined over different sets of keys.
+        [f1] is called for keys appearing only in [m1], 
+        [f2] for keys appearing only in [m2], 
+        and [f] for keys appearing in both maps.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+
+
+    val map2zo: (key -> 'a -> 'a) -> (key -> 'a -> 'a) -> (key -> 'a -> 'a -> 'a) -> 'a t -> 'a t -> 'a t
+    (** [map2zo f1 f2 f m1 m2] is similar to [map2o f1 f2 f m1 m2] but,
+        similary to [map2z], [f] is not called on physically equal
+        subtrees.
+        This is more efficient than [map2o], and equivalent if [f] is
+        side-effect free and idem-potent ([f k a a = a]).
+        The returned map has bindings for all keys appearing in either
+        [m1] or [m2].
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+        
+    val iter2zo: (key -> 'a -> unit) -> (key -> 'a -> unit) -> (key -> 'a -> 'a -> unit) -> 'a t -> 'a t -> unit
+    (** [iter2zo f1 f2 f m1 m2] is similar to [iter2o f1 f2 f m1 m2] but,
+        similary to [iter2z], [f] is not called on physically equal
+        subtrees.
+        This is more efficient than [iter2o], and equivalent if [f] is
+        side-effect free.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+        
+    val fold2zo: (key -> 'a -> 'b -> 'b) -> (key -> 'a -> 'b -> 'b) -> (key -> 'a -> 'a -> 'b -> 'b) -> 'a t -> 'a t -> 'b -> 'b
+    (** [fold2zo f1 f2 f m1 m2 a] is similar to [fold2o f1 f2 f m1 m2 a] but,
+        similary to [fold2z], [f] is not called on physically equal
+        subtrees.
+        This is more efficient than [fold2o], and equivalent if 
+        [f k a a x = x] and has no side-effect.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+        
+    val for_all2zo: (key -> 'a -> bool) -> (key -> 'a -> bool) -> (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    (** [for_all2zo f1 f2 f m1 m2] is similar to [for_all2o f1 f2 f m1 m2] but,
+        similary to [for_all2z], [f] is not called on physically equal
+        subtrees.
+        This is more efficient than [for_all2o], and equivalent if 
+        [f k a a = true] and has no side-effect.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+    val exists2zo: (key -> 'a -> bool) -> (key -> 'a -> bool) -> (key -> 'a -> 'a -> bool) -> 'a t -> 'a t -> bool
+    (** [exists2zo f1 f2 f m1 m2] is similar to [exists2o f1 f2 f m1 m2] but,
+        similary to [exists2z], [f] is not called on physically equal
+        subtrees.
+        This is more efficient than [exists2o], and equivalent if 
+        [f k a a = false] and has no side-effect.
+        The bindings are passed to [f], [f1], [f2] in increasing order of keys. *)
+
+    val map_slice: (key -> 'a -> 'a) -> 'a t -> key -> key -> 'a t
+    (** [map_slice f m k1 k2] is similar to [map f m], but only applies
+        [f] to bindings with key greater or equal to [k1] and smaller
+        or equal to [k2] to construct the returned map. Bindings with
+        keys outside this range in [m] are put unchanged in the result.
+        It is as if, outside this range, [f k a = a] and has no effect.
+        The result has the same key set as [m].
+        The bindings are passed to [f] in increasing order of keys,
+        between [k1] and [k2]. *)
+
+    val iter_slice: (key -> 'a -> unit) -> 'a t -> key -> key -> unit
+    (** [iter_slice f m k1 k2] is similar to [iter f m], but only calls
+        [f] on bindings with key greater or equal to [k1] and smaller
+        or equal to [k2].
+        It is as if, outside this range, [f k a] has no effect.
+        The bindings are passed to [f] in increasing order of keys,
+        between [k1] and [k2]. *)
+
+    val fold_slice: (key -> 'a -> 'b -> 'b) -> 'a t -> key -> key -> 'b -> 'b
+    (** [fold_slice f m k1 k2 a] is similar to [fold f m], but only calls
+        [f] on bindings with key greater or equal to [k1] and smaller
+        or equal to [k2].
+        It is as if, outside this range, [f k a x = x] and has no effect.
+        The bindings are passed to [f] in increasing order of keys,
+        between [k1] and [k2]. *)
+
+    val for_all_slice: (key -> 'a -> bool) -> 'a t -> key -> key -> bool
+    (** [for_all_slice f m k1 k2 a] is similar to [for_all f m], but only calls
+        [f] on bindings with key greater or equal to [k1] and smaller
+        or equal to [k2].
+        It is as if, outside this range, [f k a = true] and has no effect.
+        The bindings are passed to [f] in increasing order of keys,
+        between [k1] and [k2]. *)
+
+    val exists_slice: (key -> 'a -> bool) -> 'a t -> key -> key -> bool
+    (** [exists_slice f m k1 k2 a] is similar to [exists f m], but only calls
+        [f] on bindings with key greater or equal to [k1] and smaller
+        or equal to [k2].
+        It is as if, outside this range, [f k a = false] and has no effect.
+        The bindings are passed to [f] in increasing order of keys,
+        between [k1] and [k2]. *)
+
+    val key_equal: 'a t -> 'a t -> bool
+    (** [key_equal m1 m2] returns true if [m1] and [m2] are defined
+        over exactly the same set of keys (but with possibly different
+        values).
+     *)
+
+    val key_subset: 'a t -> 'a t -> bool
+    (** [key_equal m1 m2] returns true if [m1] is defined on a subset of
+        the keys of [m2] (but with possibly different values).
+     *)
+
+    val find_greater: key -> 'a t -> key * 'a
+    (** [find_greater k m] returns the binding (key and value) in [m]
+        with key strictly greater than [k] and as small as possible.
+        Raises [Not_found] if [m] has no binding for a key strictly greater
+        than [k].
+     *)
+
+    val find_less: key -> 'a t -> key * 'a
+    (** [find_less k m] returns the binding (key and value) in [m]
+        with key strictly less than [k] and as large as possible.
+        Raises [Not_found] if [m] has no binding for a key strictly less
+        than [k].
+     *)
+
+    val find_greater_equal: key -> 'a t -> key * 'a
+    (** [find_greater_euql k m] returns the binding (key and value) in [m]
+        with key greater or equal to [k] and as small as possible.
+        Raises [Not_found] if [m] has no binding for a key greater or equal
+        to [k].
+     *)
+
+    val find_less_equal: key -> 'a t -> key * 'a
+    (** [find_less_equal k m] returns the binding (key and value) in [m]
+        with key less or equal to [k] and as large as possible.
+        Raises [Not_found] if [m] has no binding for a key less or equal
+        to [k].
+     *)
+
+
+  end
+(** Output signature of the functor {!Map.Make}. *)
+
+module Make (Ord : OrderedType) : S with type key = Ord.t
+(** Functor building an implementation of the map structure
+   given a totally ordered type. *)
diff --git a/libs/util.ml b/libs/util.ml
new file mode 100644
index 0000000..30cf5bf
--- /dev/null
+++ b/libs/util.ml
@@ -0,0 +1,20 @@
+exception TypeError
+
+module VarMap = Mapext.Make(String)
+
+let rec fix equal f s =
+  let fs = f s in
+  if equal fs s
+    then fs
+    else fix equal f fs
+
+let (@@) f x = f x
+
+let print_list x l =
+    Format.printf "%s: " x;
+    let rec aux = function
+        | [] -> ()
+        | [a] -> Format.printf "%s" a
+        | p::q -> Format.printf "%s, " p; aux q
+    in
+    Format.printf "["; aux l; Format.printf "]@.";
diff --git a/main.ml b/main.ml
new file mode 100644
index 0000000..4f70229
--- /dev/null
+++ b/main.ml
@@ -0,0 +1,25 @@
+open Ast
+
+(* command line options *)
+let dump = ref false
+let ifile = ref ""
+
+let usage = "usage: analyzer [options] file.scade"
+
+let options = [
+    "--dump", Arg.Set dump, "Dump program source.";
+]
+
+let () =
+    Arg.parse options (fun f -> ifile := f) usage;
+
+    if !ifile = "" then begin
+        Format.eprintf "No input file...@.";
+        exit 1
+    end;
+
+    let prog = File_parser.parse_file !ifile in
+    if !dump then Ast_printer.print_prog Format.std_formatter prog;
+    ()  (* nothing to do yet ... *)
+    
+