Make code cleaner

8 files changed, 283 insertions, 1913 deletions

diff --git a/frontend/ast.ml b/frontend/ast.ml
index 180608c..72f7049 100644
--- a/frontend/ast.ml
+++ b/frontend/ast.ml
@@ -18,59 +18,74 @@ type typ =
 type unary_op =
     | AST_UPLUS
     | AST_UMINUS
-    | AST_NOT
-    | AST_PRE
 
 type binary_op =
+    (* num * num -> num *)
     | AST_PLUS
     | AST_MINUS
     | AST_MUL
     | AST_DIV
     | AST_MOD
 
+type binary_rel_op =
+    (* 'a * 'a -> bool *)
     | AST_EQ
     | AST_NE
-
+    (* num * num -> bool *)
     | AST_LT
     | AST_LE
     | AST_GT
     | AST_GE
 
+type bin_bool_op =
+    (* bool * bool -> bool *)
     | 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
+    | AST_identifier  of id ext
+    (* on numerical values *)
+    | AST_int_const   of string ext
+    | AST_real_const  of string ext
+    | AST_unary       of unary_op * (expr ext)
+    | AST_binary      of binary_op * (expr ext) * (expr ext)
+    (* on boolean values *)
+    | AST_bool_const  of bool
+    | AST_binary_rel  of binary_rel_op * (expr ext) * (expr ext)
+    | AST_binary_bool of bin_bool_op * (expr ext) * (expr ext)
+    | AST_not         of expr ext
+    (* temporal primitives *)
+    | AST_pre         of expr ext
+    | AST_arrow       of (expr ext) * (expr ext)
+    (* other *)
+    | AST_if          of (expr ext) * (expr ext) * (expr ext)
+    | AST_instance    of (id ext) * (expr ext list)
+    (* (TODO) and more : when, merge, activate instances, ... *)
 
 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... *)
+    | AST_assign     of (id ext) * (expr ext)
+    | AST_guarantee  of (id ext) * (expr ext)
+    | AST_assume     of (id ext) * (expr ext)
+    (* (TODO) and more : automaton, activate... *)
+
+type var_def = bool * (id ext) * typ
 
 type node_decl = {
     name : id;
-    args : (bool * (id ext) * typ) list;
-    ret : (bool * (id ext) * typ) list;
-    var : (bool * (id ext) * typ) list;
+    args : var_def list;
+    ret  : var_def list;
+    var  : var_def list;
     body : eqn ext list;
 }
 
-type const_decl = (id ext) * typ * (expr ext)
+type const_decl = {
+    name  : id;
+    typ   : typ;
+    value : expr ext;
+}
 
 type toplevel =
-    | AST_node_decl of node_decl ext
+    | 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
index a02b970..422d446 100644
--- a/frontend/ast_printer.ml
+++ b/frontend/ast_printer.ml
@@ -25,8 +25,6 @@ let string_of_extent (p,q) =
 let string_of_unary_op = function
   | AST_UPLUS -> "+"
   | AST_UMINUS -> "-"
-  | AST_NOT -> "not"
-  | AST_PRE -> "pre"
 
 let string_of_binary_op = function
   | AST_MUL -> "*"
@@ -34,29 +32,37 @@ let string_of_binary_op = function
   | AST_MOD -> "mod"
   | AST_PLUS -> "+"
   | AST_MINUS -> "-"
+let string_of_binary_rel = function
   | AST_EQ -> "="
   | AST_NE -> "<>"
   | AST_LT -> "<"
   | AST_LE -> "<="
   | AST_GT -> ">"
   | AST_GE -> ">="
+let string_of_binary_bool = function
   | 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 binary_op_precedence = function
+  | AST_MUL| AST_DIV| AST_MOD-> 51
+  | AST_PLUS  | AST_MINUS -> 50
+let binary_rel_precedence = function
+  | AST_EQ | AST_NE -> 41
+  | AST_LT | AST_LE | AST_GT | AST_GE -> 40
+let binary_bool_precedence = function
+  | AST_AND -> 31
+  | AST_OR -> 30
+let arrow_precedence = 20
+let if_precedence = 10
 
 let expr_precedence = function
-  | AST_unary (op, _) -> 99
-  | AST_binary(op, _, _) -> binary_precedence op
+  | AST_unary (_, _) | AST_pre(_) | AST_not(_) -> 99
+  | AST_binary(op, _, _) -> binary_op_precedence op
+  | AST_binary_rel(r, _, _) -> binary_rel_precedence r
+  | AST_binary_bool(r, _, _) -> binary_bool_precedence r
+  | AST_arrow(_, _) -> arrow_precedence
+  | AST_if(_, _, _) -> if_precedence
   | _ -> 100
 
 (* utility *)
@@ -87,8 +93,18 @@ let rec print_expr fmt e =
   | 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
+      then Format.fprintf fmt "(%a)" print_expr e1
+      else Format.fprintf fmt "%a" print_expr e1
+  | AST_not (e1,_) ->
+      Format.pp_print_string fmt "not ";
+      if expr_precedence e1 <= expr_precedence e
+      then Format.fprintf fmt "(%a)" print_expr e1
+      else Format.fprintf fmt "%a" print_expr e1
+  | AST_pre (e1,_) ->
+      Format.pp_print_string fmt "pre ";
+      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
@@ -98,41 +114,60 @@ let rec print_expr fmt e =
       if expr_precedence e2 <= expr_precedence e
       then Format.fprintf fmt " (%a)" print_expr e2
       else Format.fprintf fmt " %a" print_expr e2
+  | AST_binary_rel (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_rel 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_binary_bool (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_bool 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_arrow ((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 "->";
+      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_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
+        Format.fprintf fmt "%a(%a)"
+          print_id i (print_list print_expr ", ") (List.map fst l)
 
 (* 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
+      Format.fprintf fmt "%s%s = %a;@\n" 
+        ind v print_expr e
   | AST_assume((i, _), (e, _)) ->
-    Format.fprintf fmt "%sassume %s : %a;@\n"
-        ind i print_expr 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
+      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
@@ -141,33 +176,28 @@ and print_block ind fmt b =
 
 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
+      (if pr then "probe " else "")
+      i
+      (string_of_typ ty)
 
-let print_node_decl fmt d =
+let print_node_decl fmt (d : node_decl) =
     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;
+      d.name
+      (print_list print_var_decl "; ") d.args
+      (print_list print_var_decl "; ") d.ret;
+    if d.var <> [] then begin
+      Format.fprintf fmt "var";
+      List.iter (fun d -> Format.fprintf fmt " %a;" print_var_decl d) d.var;
+      Format.fprintf fmt "@\n"
+    end;
     Format.fprintf fmt "let@\n%atel@\n@\n"
-        (print_block "") d.body
+      (print_block "") d.body
 
-let print_const_decl fmt ((i, _), ty, (e, _)) =
+let print_const_decl fmt (d : const_decl) =
     Format.fprintf fmt
-        "const %s: %s = %a@\n@\n"
-        i (string_of_typ ty)
-        print_expr e
+      "const %s: %s = %a@\n@\n"
+      d.name (string_of_typ d.typ)
+      print_expr (fst d.value)
 
 let print_toplevel fmt = function
     | AST_node_decl (n, _) -> print_node_decl fmt n
diff --git a/frontend/file_parser.ml b/frontend/file_parser.ml
index 0e975ce..672c695 100644
--- a/frontend/file_parser.ml
+++ b/frontend/file_parser.ml
@@ -3,17 +3,17 @@ 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"
+  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
index 9d6c208..1fd638b 100644
--- a/frontend/lexer.mll
+++ b/frontend/lexer.mll
@@ -1,105 +1,90 @@
 {
-    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;
-        ]
-
+  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 }
+let const_real = digit_+ '.' digit*
 
+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 }
+  | "/"    { DIVIDE }
+  | "<"    { LESS }
+  | ">"    { GREATER }
+  | "<="   { LESS_EQUAL }
+  | ">="   { GREATER_EQUAL }
+  | "<>"   { DIFF }
+  | "="    { EQUAL }
+  | ";"    { SEMICOLON }
+  | ":"    { COLON }
+  | ","    { COMMA }
+  | "->"   { ARROW }
+  (* literals *)
+  | const_int    as c { INTVAL c }
+  | const_real   as c { REALVAL 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 }
+  | "*)" { () }
+  | [^ '\n' '\r'] { comment lexbuf }
+  | newline { new_line lexbuf; comment lexbuf }
diff --git a/frontend/parser.automaton b/frontend/parser.automaton
deleted file mode 100644
index dff892b..0000000
--- a/frontend/parser.automaton
+++ /dev/null
@@ -1,1577 +0,0 @@
-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
deleted file mode 100644
index 296156a..0000000
--- a/frontend/parser.conflicts
+++ /dev/null
@@ -1,32 +0,0 @@
-
-** 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
index 9db1bd5..2c1ac25 100644
--- a/frontend/parser.mly
+++ b/frontend/parser.mly
@@ -2,62 +2,32 @@
 open Ast
 %}
 
-/* tokens */
-/**********/
-
-%token BOOL
-%token INT
-%token REAL
+%token BOOL INT REAL
 %token PROBE
-%token TRUE
-%token THEN
-%token FALSE
-%token IF
-%token ELSE
-%token NOT
-%token AND
-%token OR
+%token TRUE FALSE
+%token IF THEN ELSE
+%token NOT AND OR
 %token MOD
-%token CONST
-%token NODE
-%token RETURNS
-%token VAR
-%token LET
-%token TEL
+%token CONST NODE RETURNS
+%token VAR LET 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 ASSUME GUARANTEE
+
+%token LPAREN RPAREN
+%token LCURLY RCURLY
+%token STAR PLUS MINUS DIVIDE
+%token LESS GREATER LESS_EQUAL GREATER_EQUAL
+%token DIFF EQUAL
+%token SEMICOLON COLON COMMA
 %token ARROW
 
 %token <string> IDENT
 %token <string> INTVAL
+%token <string> REALVAL
 
 %token EOF
 
-/* priorities of binary operators (lowest to highest) */
+(* Lowest priorities first *)
 %left ARROW
 %left OR
 %left AND
@@ -66,53 +36,46 @@ open Ast
 %left PLUS MINUS
 %left STAR DIVIDE MOD
 
-
-/* entry-points */
-/****************/
-
+(* Root token *)
 %start<Ast.toplevel list> file
 
-
 %%
 
-
-/* toplevel */
-/************/
-
-file: t=list(toplevel) EOF { t }
+file:
+| t=list(toplevel) EOF      { t }
 
 toplevel:
-| d=ext(const_decl)           { AST_const_decl d }
-| d=ext(node_decl)       { AST_node_decl d }
-
+| 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 }
+| LPAREN e=expr RPAREN      { e }
+| e=ext(IDENT)              { AST_identifier e }
+| e=ext(INTVAL)             { AST_int_const e }
+| e=ext(REALVAL)            { AST_real_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) }
-
+                            { AST_instance (e, l) }
 
 unary_expr:
 | e=primary_expr                   { e }
+| NOT e=ext(unary_expr)            { AST_not(e) }
+| PRE e=ext(unary_expr)            { AST_pre(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) ARROW f=ext(binary_expr)         { AST_arrow(e, f) }
 | e=ext(binary_expr) o=binary_op f=ext(binary_expr)   { AST_binary (o, e, f) }
+| e=ext(binary_expr) o=binary_rel f=ext(binary_expr)  { AST_binary_rel (o, e, f) }
+| e=ext(binary_expr) o=binary_bool f=ext(binary_expr) { AST_binary_bool (o, e, f) }
 
 %inline binary_op:
 | STAR           { AST_MUL }
@@ -120,55 +83,44 @@ binary_expr:
 | MOD            { AST_MOD }
 | PLUS           { AST_PLUS }
 | MINUS          { AST_MINUS }
+%inline binary_rel:
 | LESS           { AST_LT }
 | GREATER        { AST_GT }
 | LESS_EQUAL     { AST_LE }
 | GREATER_EQUAL  { AST_GE }
 | EQUAL          { AST_EQ}
 | DIFF           { AST_NE }
+%inline binary_bool:
 | 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 }
+| 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 }
+| e=if_expr      { e }
 
 
-/* equations */
-/****************/
-
+(* Equations (can be asserts, automata, ...) *)
 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) }
+| i=ext(IDENT) 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 }
 
+(* Declarations *)
 dbody:
-| e=ext(eqn) SEMICOLON
-    { [e] }
+| e=ext(eqn) SEMICOLON                          { [e] }
 | LET l=nonempty_list(terminated(ext(eqn), SEMICOLON)) TEL
-    { l }
-
-/* declarations */
+                                                { l }
 
 var:
-|   p=boption(PROBE) i=ext(IDENT)
-    { (p, i) }
+|   p=boption(PROBE) i=ext(IDENT)   { (p, i) }
 
 vari:
 |   vn=separated_list(COMMA, var) COLON t=typ
@@ -179,43 +131,40 @@ vars:
     { List.flatten v }
 
 const_decl:
-| CONST i=ext(IDENT) COLON t=typ EQUAL e=ext(expr) SEMICOLON
-    { (i, t, e) }
+| CONST i=IDENT COLON t=typ EQUAL e=ext(expr) SEMICOLON
+    { {
+        name = i;
+        typ = t;
+        value = e;
+    } }
 
 var_decl:
 | VAR l=nonempty_list(terminated(vari, SEMICOLON))
     { List.flatten l }
 
 node_decl:
-| NODE id=IDENT
-    LPAREN v=vars RPAREN
+| 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
+{ { 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 */
+{ { name = id;
+    args = v;
+    ret = rv;
+    var = lv;
+    body = b;
+} }
+
+(* Utility : add extent information *)
 %inline ext(X): 
 | x=X { x, ($startpos, $endpos) }
 
-
 %%
diff --git a/libs/util.ml b/libs/util.ml
index 30cf5bf..2150abc 100644
--- a/libs/util.ml
+++ b/libs/util.ml
@@ -11,10 +11,10 @@ let rec fix equal f s =
 let (@@) f x = f x
 
 let print_list x l =
-    Format.printf "%s: " x;
-    let rec aux = function
-        | [] -> ()
-        | [a] -> Format.printf "%s" a
-        | p::q -> Format.printf "%s, " p; aux q
-    in
-    Format.printf "["; aux l; Format.printf "]@.";
+  Format.printf "%s: " x;
+  let rec aux = function
+    | [] -> ()
+    | [a] -> Format.printf "%s" a
+    | p::q -> Format.printf "%s, " p; aux q
+  in
+  Format.printf "["; aux l; Format.printf "]@.";