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

7 files changed, 2207 insertions, 0 deletions

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) }
+
+
+%%